@classroomio/mcp 0.0.2

package/dist/index.js

@@ -0,0 +1,830 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/api-client.ts
+var ClassroomIoApiError = class extends Error {
+  constructor(message, status, code, field) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.field = field;
+    this.name = "ClassroomIoApiError";
+  }
+};
+var ClassroomIoApiClient = class {
+  constructor(config) {
+    this.config = config;
+  }
+  async createCourseDraft(payload) {
+    return this.request("/organization/course-import/drafts", {
+      method: "POST",
+      body: payload
+    });
+  }
+  async createCourseDraftFromCourse(payload) {
+    return this.request("/organization/course-import/drafts/from-course", {
+      method: "POST",
+      body: payload
+    });
+  }
+  async getCourseStructure(courseId) {
+    return this.request(`/organization/course-import/courses/${courseId}/structure`, {
+      method: "GET"
+    });
+  }
+  async getCourseDraft(draftId) {
+    return this.request(`/organization/course-import/drafts/${draftId}`, {
+      method: "GET"
+    });
+  }
+  async updateCourseDraft(draftId, payload) {
+    return this.request(`/organization/course-import/drafts/${draftId}`, {
+      method: "PUT",
+      body: payload
+    });
+  }
+  async publishCourseDraft(draftId, payload) {
+    return this.request(`/organization/course-import/drafts/${draftId}/publish`, {
+      method: "POST",
+      body: payload
+    });
+  }
+  async publishCourseDraftToExistingCourse(draftId, payload) {
+    return this.request(`/organization/course-import/drafts/${draftId}/publish-existing-course`, {
+      method: "POST",
+      body: payload
+    });
+  }
+  async request(path, options) {
+    const response = await fetch(new URL(path, this.config.CLASSROOMIO_API_URL), {
+      method: options.method,
+      headers: {
+        Authorization: `Bearer ${this.config.CLASSROOMIO_API_KEY}`,
+        "content-type": "application/json",
+        "user-agent": this.config.CLASSROOMIO_USER_AGENT
+      },
+      body: options.body ? JSON.stringify(options.body) : void 0
+    });
+    const json = await response.json().catch(() => null);
+    if (!response.ok) {
+      const errorPayload = json;
+      throw new ClassroomIoApiError(
+        errorPayload?.error ?? errorPayload?.message ?? `ClassroomIO request failed with status ${response.status}`,
+        response.status,
+        errorPayload?.code,
+        errorPayload?.field
+      );
+    }
+    if (!json || typeof json !== "object" || !("success" in json) || !json.success) {
+      throw new ClassroomIoApiError("ClassroomIO returned an invalid response payload", response.status);
+    }
+    return json.data;
+  }
+};
+
+// src/config.ts
+import { z } from "zod";
+var ZConfig = z.object({
+  CLASSROOMIO_API_URL: z.url().default("https://api.classroomio.com"),
+  CLASSROOMIO_API_KEY: z.string().min(1),
+  CLASSROOMIO_USER_AGENT: z.string().min(1).default("classroomio-mcp/0.0.1")
+});
+function getConfig(env = process.env) {
+  return ZConfig.parse(env);
+}
+
+// ../utils/dist/validation/course-import/course-import.js
+import * as z3 from "zod";
+
+// ../utils/dist/validation/course/course.js
+import * as z2 from "zod";
+
+// ../question-types/dist/question-type-keys.js
+var QUESTION_TYPE_KEY = {
+  RADIO: "RADIO",
+  CHECKBOX: "CHECKBOX",
+  TEXTAREA: "TEXTAREA",
+  TRUE_FALSE: "TRUE_FALSE",
+  SHORT_ANSWER: "SHORT_ANSWER",
+  NUMERIC: "NUMERIC",
+  FILL_BLANK: "FILL_BLANK",
+  FILE_UPLOAD: "FILE_UPLOAD",
+  MATCHING: "MATCHING",
+  ORDERING: "ORDERING",
+  HOTSPOT: "HOTSPOT",
+  LINK: "LINK"
+};
+var LEGACY_QUESTION_TYPE_KEYS = [
+  QUESTION_TYPE_KEY.RADIO,
+  QUESTION_TYPE_KEY.CHECKBOX,
+  QUESTION_TYPE_KEY.TEXTAREA
+];
+
+// ../question-types/dist/question-type-registry.js
+var QUESTION_TYPE_REGISTRY = [
+  {
+    key: QUESTION_TYPE_KEY.RADIO,
+    typename: "RADIO",
+    label: "Single answer",
+    id: 1,
+    autoGradable: true,
+    supportsPartialCredit: false,
+    manualGradingRequired: false
+  },
+  {
+    key: QUESTION_TYPE_KEY.CHECKBOX,
+    typename: "CHECKBOX",
+    label: "Multiple answers",
+    id: 2,
+    autoGradable: true,
+    supportsPartialCredit: true,
+    manualGradingRequired: false
+  },
+  {
+    key: QUESTION_TYPE_KEY.TEXTAREA,
+    typename: "TEXTAREA",
+    label: "Paragraph",
+    id: 3,
+    autoGradable: false,
+    supportsPartialCredit: false,
+    manualGradingRequired: true
+  },
+  {
+    key: QUESTION_TYPE_KEY.TRUE_FALSE,
+    typename: "TRUE_FALSE",
+    label: "True/False",
+    id: 4,
+    autoGradable: true,
+    supportsPartialCredit: false,
+    manualGradingRequired: false
+  },
+  {
+    key: QUESTION_TYPE_KEY.SHORT_ANSWER,
+    typename: "SHORT_ANSWER",
+    label: "Short answer",
+    id: 5,
+    autoGradable: false,
+    supportsPartialCredit: false,
+    manualGradingRequired: true
+  },
+  {
+    key: QUESTION_TYPE_KEY.NUMERIC,
+    typename: "NUMERIC",
+    label: "Numeric answer",
+    id: 6,
+    autoGradable: true,
+    supportsPartialCredit: true,
+    manualGradingRequired: false
+  },
+  {
+    key: QUESTION_TYPE_KEY.FILL_BLANK,
+    typename: "FILL_BLANK",
+    label: "Fill in the blank",
+    id: 7,
+    autoGradable: true,
+    supportsPartialCredit: true,
+    manualGradingRequired: false
+  },
+  {
+    key: QUESTION_TYPE_KEY.FILE_UPLOAD,
+    typename: "FILE_UPLOAD",
+    label: "File upload",
+    id: 8,
+    autoGradable: false,
+    supportsPartialCredit: false,
+    manualGradingRequired: true
+  },
+  {
+    key: QUESTION_TYPE_KEY.MATCHING,
+    typename: "MATCHING",
+    label: "Matching",
+    id: 9,
+    autoGradable: true,
+    supportsPartialCredit: true,
+    manualGradingRequired: false
+  },
+  {
+    key: QUESTION_TYPE_KEY.ORDERING,
+    typename: "ORDERING",
+    label: "Ordering",
+    id: 10,
+    autoGradable: true,
+    supportsPartialCredit: true,
+    manualGradingRequired: false
+  },
+  {
+    key: QUESTION_TYPE_KEY.HOTSPOT,
+    typename: "HOTSPOT",
+    label: "Hotspot",
+    id: 11,
+    autoGradable: true,
+    supportsPartialCredit: true,
+    manualGradingRequired: false
+  },
+  {
+    key: QUESTION_TYPE_KEY.LINK,
+    typename: "LINK",
+    label: "Links",
+    id: 12,
+    autoGradable: false,
+    supportsPartialCredit: false,
+    manualGradingRequired: true
+  }
+];
+var QUESTION_TYPE_BY_KEY = Object.freeze(QUESTION_TYPE_REGISTRY.reduce((acc, type) => {
+  acc[type.key] = type;
+  return acc;
+}, {}));
+var QUESTION_TYPE_IDS = Object.freeze(QUESTION_TYPE_REGISTRY.reduce((acc, type) => {
+  acc[type.key] = type.id;
+  return acc;
+}, {}));
+var QUESTION_TYPE_TYPENAME_TO_KEY = Object.freeze(QUESTION_TYPE_REGISTRY.reduce((acc, type) => {
+  acc[type.typename] = type.key;
+  return acc;
+}, {}));
+var QUESTION_TYPE_ID_TO_KEY = Object.freeze(QUESTION_TYPE_REGISTRY.reduce((acc, type) => {
+  acc[type.id] = type.key;
+  return acc;
+}, {}));
+
+// ../question-types/dist/answer-codecs.js
+var TRUE_LABELS = /* @__PURE__ */ new Set(["true", "1", "yes"]);
+var FALSE_LABELS = /* @__PURE__ */ new Set(["false", "0", "no"]);
+function labelToBoolean(label) {
+  const normalized = label.trim().toLowerCase();
+  if (TRUE_LABELS.has(normalized))
+    return true;
+  if (FALSE_LABELS.has(normalized))
+    return false;
+  return void 0;
+}
+var RADIO_CODEC = {
+  type: "RADIO",
+  toApiPayload(data, questionId) {
+    return { questionId, optionId: data.optionId };
+  },
+  fromApiPayload(payload) {
+    const optionId = payload.optionId;
+    if (optionId === void 0 || Number.isNaN(optionId))
+      return null;
+    return { type: "RADIO", optionId };
+  }
+};
+var CHECKBOX_CODEC = {
+  type: "CHECKBOX",
+  toApiPayload(data, questionId) {
+    return {
+      questionId,
+      answer: JSON.stringify({ type: "CHECKBOX", optionIds: data.optionIds })
+    };
+  },
+  fromApiPayload(payload) {
+    if (!payload.answer)
+      return null;
+    const { optionIds } = JSON.parse(payload.answer);
+    if (!Array.isArray(optionIds))
+      return null;
+    return { type: "CHECKBOX", optionIds };
+  }
+};
+var TRUE_FALSE_CODEC = {
+  type: "TRUE_FALSE",
+  toApiPayload(data, questionId) {
+    return { questionId, answer: String(data.value) };
+  },
+  fromApiPayload(payload) {
+    if (payload.answer === void 0)
+      return null;
+    const resolved = labelToBoolean(payload.answer);
+    if (resolved === void 0)
+      return null;
+    return { type: "TRUE_FALSE", value: resolved };
+  }
+};
+var TEXTAREA_CODEC = {
+  type: "TEXTAREA",
+  toApiPayload(data, questionId) {
+    return { questionId, answer: data.text };
+  },
+  fromApiPayload(payload) {
+    if (payload.answer === void 0)
+      return null;
+    return { type: "TEXTAREA", text: payload.answer };
+  }
+};
+var SHORT_ANSWER_CODEC = {
+  type: "SHORT_ANSWER",
+  toApiPayload(data, questionId) {
+    return { questionId, answer: data.text };
+  },
+  fromApiPayload(payload) {
+    if (payload.answer === void 0)
+      return null;
+    return { type: "SHORT_ANSWER", text: payload.answer };
+  }
+};
+var NUMERIC_CODEC = {
+  type: "NUMERIC",
+  toApiPayload(data, questionId) {
+    return { questionId, answer: JSON.stringify({ type: "NUMERIC", value: data.value }) };
+  },
+  fromApiPayload(payload) {
+    if (!payload.answer)
+      return null;
+    const { value } = JSON.parse(payload.answer);
+    return { type: "NUMERIC", value };
+  }
+};
+var FILL_BLANK_CODEC = {
+  type: "FILL_BLANK",
+  toApiPayload(data, questionId) {
+    return { questionId, answer: JSON.stringify({ type: "FILL_BLANK", answers: data.values }) };
+  },
+  fromApiPayload(payload) {
+    if (!payload.answer)
+      return null;
+    const { answers } = JSON.parse(payload.answer);
+    const values = answers.map((v) => String(v).trim()).filter(Boolean);
+    return values.length > 0 ? { type: "FILL_BLANK", values } : null;
+  }
+};
+var FILE_UPLOAD_CODEC = {
+  type: "FILE_UPLOAD",
+  toApiPayload(data, questionId) {
+    const obj = { fileKey: data.fileKey, fileName: data.fileName, mimeType: data.mimeType, size: data.size };
+    return { questionId, answer: JSON.stringify(obj) };
+  },
+  fromApiPayload(payload) {
+    if (!payload.answer)
+      return null;
+    const p = JSON.parse(payload.answer);
+    return {
+      type: "FILE_UPLOAD",
+      fileKey: p.fileKey,
+      fileName: p.fileName ?? "",
+      mimeType: p.mimeType,
+      size: p.size
+    };
+  }
+};
+var MATCHING_CODEC = {
+  type: "MATCHING",
+  toApiPayload(data, questionId) {
+    return { questionId, answer: JSON.stringify({ type: "MATCHING", value: data.pairs }) };
+  },
+  fromApiPayload(payload) {
+    if (!payload.answer)
+      return null;
+    const { value: pairs } = JSON.parse(payload.answer);
+    return pairs.length > 0 ? { type: "MATCHING", pairs } : null;
+  }
+};
+var ORDERING_CODEC = {
+  type: "ORDERING",
+  toApiPayload(data, questionId) {
+    return { questionId, answer: JSON.stringify({ type: "ORDERING", value: data.orderedValues }) };
+  },
+  fromApiPayload(payload) {
+    if (!payload.answer)
+      return null;
+    const { value: orderedValues } = JSON.parse(payload.answer);
+    return orderedValues.length > 0 ? { type: "ORDERING", orderedValues } : null;
+  }
+};
+var LINK_CODEC = {
+  type: "LINK",
+  toApiPayload(data, questionId) {
+    return { questionId, answer: JSON.stringify({ type: "LINK", links: data.urls }) };
+  },
+  fromApiPayload(payload) {
+    if (!payload.answer)
+      return null;
+    const { links } = JSON.parse(payload.answer);
+    const urls = links.map((v) => String(v).trim()).filter(Boolean);
+    return urls.length > 0 ? { type: "LINK", urls } : null;
+  }
+};
+var HOTSPOT_CODEC = {
+  type: "HOTSPOT",
+  toApiPayload(data, questionId) {
+    return { questionId, answer: JSON.stringify({ type: "HOTSPOT", value: data.coordinates }) };
+  },
+  fromApiPayload(payload) {
+    if (!payload.answer)
+      return null;
+    const { value: coordinates } = JSON.parse(payload.answer);
+    return coordinates.length > 0 ? { type: "HOTSPOT", coordinates } : null;
+  }
+};
+var ANSWER_CODECS = {
+  [QUESTION_TYPE_KEY.RADIO]: RADIO_CODEC,
+  [QUESTION_TYPE_KEY.CHECKBOX]: CHECKBOX_CODEC,
+  [QUESTION_TYPE_KEY.TRUE_FALSE]: TRUE_FALSE_CODEC,
+  [QUESTION_TYPE_KEY.TEXTAREA]: TEXTAREA_CODEC,
+  [QUESTION_TYPE_KEY.SHORT_ANSWER]: SHORT_ANSWER_CODEC,
+  [QUESTION_TYPE_KEY.NUMERIC]: NUMERIC_CODEC,
+  [QUESTION_TYPE_KEY.FILL_BLANK]: FILL_BLANK_CODEC,
+  [QUESTION_TYPE_KEY.FILE_UPLOAD]: FILE_UPLOAD_CODEC,
+  [QUESTION_TYPE_KEY.MATCHING]: MATCHING_CODEC,
+  [QUESTION_TYPE_KEY.ORDERING]: ORDERING_CODEC,
+  [QUESTION_TYPE_KEY.LINK]: LINK_CODEC,
+  [QUESTION_TYPE_KEY.HOTSPOT]: HOTSPOT_CODEC
+};
+
+// ../utils/dist/validation/constants.js
+var ALLOWED_CONTENT_TYPES = ["video/mp4", "video/quicktime", "video/x-msvideo", "video/x-matroska"];
+var ALLOWED_DOCUMENT_TYPES = [
+  "application/pdf",
+  "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  // .docx
+  "application/msword"
+  // .doc
+];
+
+// ../utils/dist/validation/course/course.js
+var ZCourseClone = z2.object({
+  title: z2.string().min(1),
+  description: z2.string().optional(),
+  slug: z2.string().min(1),
+  organizationId: z2.string().min(1)
+});
+var ZCourseCloneParam = z2.object({
+  courseId: z2.string().min(1)
+});
+var ZCourseGetParam = z2.object({
+  courseId: z2.string().min(1)
+});
+var ZCourseGetQuery = z2.object({
+  slug: z2.string().optional()
+});
+var ZCourseGetBySlugParam = z2.object({
+  slug: z2.string().min(1)
+});
+var ZCourseEnrollParam = z2.object({
+  courseId: z2.string().min(1)
+});
+var ZCourseEnrollBody = z2.object({
+  inviteToken: z2.string().min(1).optional()
+});
+var ZCourseDownloadParam = z2.object({
+  courseId: z2.string().min(1)
+});
+var ZCertificateDownload = z2.object({
+  theme: z2.string().min(1),
+  studentName: z2.string().min(1),
+  courseName: z2.string().min(1),
+  courseDescription: z2.string().min(1),
+  orgName: z2.string().min(1),
+  orgLogoUrl: z2.string().url().optional(),
+  facilitator: z2.string().optional()
+});
+var ZCourseDownloadContent = z2.object({
+  courseTitle: z2.string().min(1),
+  orgName: z2.string().min(1),
+  orgTheme: z2.string().min(1),
+  lessons: z2.array(z2.object({
+    lessonTitle: z2.string().min(1),
+    lessonNumber: z2.string().min(1),
+    lessonNote: z2.string(),
+    slideUrl: z2.string().url().optional(),
+    video: z2.array(z2.string().url()).optional()
+  }))
+});
+var ZLessonDownloadContent = z2.object({
+  title: z2.string().min(1),
+  number: z2.string().min(1),
+  orgName: z2.string().min(1),
+  note: z2.string(),
+  slideUrl: z2.string().url().optional(),
+  video: z2.array(z2.string().url()).optional(),
+  courseTitle: z2.string().min(1)
+});
+var ZCoursePresignUrlUpload = z2.object({
+  fileName: z2.string().min(1),
+  fileType: z2.enum(ALLOWED_CONTENT_TYPES)
+});
+var ZCourseDocumentPresignUrlUpload = z2.object({
+  fileName: z2.string().min(1),
+  fileType: z2.enum(ALLOWED_DOCUMENT_TYPES)
+});
+var ZCourseDownloadPresignedUrl = z2.object({
+  keys: z2.array(z2.string().min(1)).min(1)
+});
+var ZCourseContentUpdateItem = z2.object({
+  id: z2.string().min(1),
+  type: z2.enum(["LESSON", "EXERCISE"]),
+  isUnlocked: z2.boolean().optional(),
+  order: z2.number().int().min(0).optional(),
+  sectionId: z2.string().nullable().optional()
+});
+var ZCourseContentUpdate = z2.object({
+  items: z2.array(ZCourseContentUpdateItem).min(1)
+});
+var ZCourseContentDeleteItem = z2.object({
+  id: z2.string().min(1),
+  type: z2.enum(["LESSON", "EXERCISE"])
+});
+var ZCourseContentDelete = z2.object({
+  sectionId: z2.string().min(1).optional(),
+  items: z2.array(ZCourseContentDeleteItem).min(1).optional()
+}).refine((data) => Boolean(data.sectionId) !== Boolean(data.items), {
+  message: "Provide either sectionId or items",
+  path: ["sectionId"]
+});
+var ZCourseCreate = z2.object({
+  title: z2.string().min(1),
+  description: z2.string().min(1),
+  type: z2.enum(["LIVE_CLASS", "SELF_PACED"]),
+  organizationId: z2.string().min(1)
+});
+var ZCourseMetadata = z2.object({
+  requirements: z2.string().optional(),
+  description: z2.string().optional(),
+  goals: z2.string().optional(),
+  videoUrl: z2.string().optional(),
+  showDiscount: z2.boolean().optional(),
+  discount: z2.number().optional(),
+  paymentLink: z2.string().optional(),
+  reward: z2.object({
+    show: z2.boolean(),
+    description: z2.string()
+  }).optional(),
+  instructor: z2.object({
+    name: z2.string(),
+    role: z2.string(),
+    coursesNo: z2.number(),
+    description: z2.string(),
+    imgUrl: z2.string()
+  }).optional(),
+  certificate: z2.object({
+    templateUrl: z2.string()
+  }).optional(),
+  reviews: z2.array(z2.object({
+    id: z2.number(),
+    hide: z2.boolean(),
+    name: z2.string(),
+    avatar_url: z2.string(),
+    rating: z2.number(),
+    created_at: z2.number(),
+    description: z2.string()
+  })).optional(),
+  lessonTabsOrder: z2.array(z2.object({
+    id: z2.union([z2.literal(1), z2.literal(2), z2.literal(3), z2.literal(4)]),
+    name: z2.string()
+  })).optional(),
+  grading: z2.boolean().optional(),
+  lessonDownload: z2.boolean().optional(),
+  allowNewStudent: z2.boolean(),
+  sectionDisplay: z2.record(z2.string(), z2.boolean()).optional(),
+  isContentGroupingEnabled: z2.boolean().optional()
+});
+var ZCourseUpdate = z2.object({
+  title: z2.string().min(1).optional(),
+  description: z2.string().min(1).optional(),
+  type: z2.enum(["LIVE_CLASS", "SELF_PACED"]).optional(),
+  logo: z2.string().optional(),
+  slug: z2.string().optional(),
+  isPublished: z2.boolean().optional(),
+  overview: z2.string().optional(),
+  metadata: ZCourseMetadata.optional(),
+  isCertificateDownloadable: z2.boolean().optional(),
+  certificateTheme: z2.string().optional(),
+  tagIds: z2.array(z2.uuid()).max(100).optional()
+});
+var ZCourseUpdateParam = z2.object({
+  courseId: z2.string().min(1)
+});
+var ZCourseDeleteParam = z2.object({
+  courseId: z2.string().min(1)
+});
+var ZCourseProgressParam = z2.object({
+  courseId: z2.string().min(1)
+});
+var ZCourseProgressQuery = z2.object({
+  profileId: z2.string().uuid()
+});
+var ZCourseUserAnalyticsParam = z2.object({
+  courseId: z2.string().min(1),
+  userId: z2.string().uuid()
+});
+
+// ../utils/dist/validation/course-import/course-import.js
+var ZSupportedLocale = z3.enum(["en", "hi", "fr", "pt", "de", "vi", "ru", "es", "pl", "da"]);
+var ZCourseImportWarning = z3.object({
+  code: z3.string().min(1),
+  message: z3.string().min(1),
+  severity: z3.enum(["info", "warning", "error"])
+});
+var ZCourseImportSourceReference = z3.object({
+  type: z3.enum(["prompt", "pdf", "course"]),
+  label: z3.string().min(1),
+  pageStart: z3.number().int().min(1).optional(),
+  pageEnd: z3.number().int().min(1).optional()
+});
+var ZCourseImportDraftCourse = z3.object({
+  title: z3.string().min(1),
+  description: z3.string().min(1),
+  type: z3.enum(["LIVE_CLASS", "SELF_PACED"]),
+  locale: ZSupportedLocale.default("en"),
+  metadata: ZCourseMetadata.optional()
+});
+var ZCourseImportDraftSection = z3.object({
+  externalId: z3.string().min(1),
+  title: z3.string().min(1),
+  order: z3.number().int().min(0)
+});
+var ZCourseImportDraftLesson = z3.object({
+  externalId: z3.string().min(1),
+  sectionExternalId: z3.string().min(1),
+  title: z3.string().min(1),
+  order: z3.number().int().min(0),
+  isUnlocked: z3.boolean().optional(),
+  public: z3.boolean().optional()
+});
+var ZCourseImportDraftLessonLanguage = z3.object({
+  lessonExternalId: z3.string().min(1),
+  locale: ZSupportedLocale,
+  content: z3.string().min(1)
+});
+var ZCourseImportDraftPayload = z3.object({
+  course: ZCourseImportDraftCourse,
+  sections: z3.array(ZCourseImportDraftSection).min(1),
+  lessons: z3.array(ZCourseImportDraftLesson).min(1),
+  lessonLanguages: z3.array(ZCourseImportDraftLessonLanguage).min(1),
+  exercises: z3.array(z3.record(z3.string(), z3.unknown())).optional(),
+  sourceReferences: z3.array(ZCourseImportSourceReference).optional(),
+  warnings: z3.array(ZCourseImportWarning).default([])
+}).superRefine((value, ctx) => {
+  const sectionIds = /* @__PURE__ */ new Set();
+  value.sections.forEach((section, index) => {
+    if (sectionIds.has(section.externalId)) {
+      ctx.addIssue({
+        code: z3.ZodIssueCode.custom,
+        path: ["sections", index, "externalId"],
+        message: "Section externalId must be unique"
+      });
+    }
+    sectionIds.add(section.externalId);
+  });
+  const lessonIds = /* @__PURE__ */ new Set();
+  value.lessons.forEach((lesson, index) => {
+    if (lessonIds.has(lesson.externalId)) {
+      ctx.addIssue({
+        code: z3.ZodIssueCode.custom,
+        path: ["lessons", index, "externalId"],
+        message: "Lesson externalId must be unique"
+      });
+    }
+    lessonIds.add(lesson.externalId);
+    if (!sectionIds.has(lesson.sectionExternalId)) {
+      ctx.addIssue({
+        code: z3.ZodIssueCode.custom,
+        path: ["lessons", index, "sectionExternalId"],
+        message: "Lesson sectionExternalId must reference an existing section"
+      });
+    }
+  });
+  value.lessonLanguages.forEach((lessonLanguage, index) => {
+    if (!lessonIds.has(lessonLanguage.lessonExternalId)) {
+      ctx.addIssue({
+        code: z3.ZodIssueCode.custom,
+        path: ["lessonLanguages", index, "lessonExternalId"],
+        message: "Lesson language must reference an existing lesson"
+      });
+    }
+  });
+});
+var ZCourseImportDraftCreate = z3.object({
+  sourceType: z3.enum(["prompt", "pdf", "course"]),
+  idempotencyKey: z3.string().min(1).optional(),
+  summary: z3.record(z3.string(), z3.unknown()).optional(),
+  sourceArtifacts: z3.array(z3.record(z3.string(), z3.unknown())).optional(),
+  draft: ZCourseImportDraftPayload
+});
+var ZCourseImportCourseParam = z3.object({
+  courseId: z3.string().min(1)
+});
+var ZCourseImportDraftCreateFromCourse = z3.object({
+  courseId: z3.string().min(1),
+  idempotencyKey: z3.string().min(1).optional(),
+  summary: z3.record(z3.string(), z3.unknown()).optional(),
+  sourceArtifacts: z3.array(z3.record(z3.string(), z3.unknown())).optional()
+});
+var ZCourseImportDraftGetParam = z3.object({
+  draftId: z3.string().uuid()
+});
+var ZCourseImportDraftUpdate = z3.object({
+  summary: z3.record(z3.string(), z3.unknown()).optional(),
+  sourceArtifacts: z3.array(z3.record(z3.string(), z3.unknown())).optional(),
+  warnings: z3.array(ZCourseImportWarning).optional(),
+  draft: ZCourseImportDraftPayload.optional()
+});
+var ZCourseImportDraftPublish = z3.object({
+  title: z3.string().min(1).optional(),
+  description: z3.string().min(1).optional(),
+  type: z3.enum(["LIVE_CLASS", "SELF_PACED"]).optional(),
+  metadata: ZCourseMetadata.optional()
+});
+var ZCourseImportDraftPublishToCourse = ZCourseImportDraftPublish.extend({
+  courseId: z3.string().min(1)
+});
+
+// src/tools/course-drafts.ts
+var ZUpdateCourseDraftToolInput = ZCourseImportDraftUpdate.extend({
+  draftId: ZCourseImportDraftGetParam.shape.draftId
+});
+var ZPublishCourseDraftToolInput = ZCourseImportDraftPublish.extend({
+  draftId: ZCourseImportDraftGetParam.shape.draftId
+});
+var ZPublishCourseDraftToExistingCourseToolInput = ZCourseImportDraftPublishToCourse.extend({
+  draftId: ZCourseImportDraftGetParam.shape.draftId
+});
+var createCourseDraftShape = ZCourseImportDraftCreate.shape;
+var createCourseDraftFromCourseShape = ZCourseImportDraftCreateFromCourse.shape;
+var getCourseStructureShape = ZCourseImportCourseParam.shape;
+var getCourseDraftShape = ZCourseImportDraftGetParam.shape;
+var updateCourseDraftShape = ZUpdateCourseDraftToolInput.shape;
+var publishCourseDraftShape = ZPublishCourseDraftToolInput.shape;
+var publishCourseDraftToExistingCourseShape = ZPublishCourseDraftToExistingCourseToolInput.shape;
+function registerCourseDraftTools(server, apiClient) {
+  server.tool("get_course_structure", getCourseStructureShape, async (args) => {
+    const { courseId } = ZCourseImportCourseParam.parse(args);
+    const result = await apiClient.getCourseStructure(courseId);
+    return jsonContent(result);
+  });
+  server.tool("create_course_draft", createCourseDraftShape, async (args) => {
+    const payload = ZCourseImportDraftCreate.parse(args);
+    const result = await apiClient.createCourseDraft(payload);
+    return jsonContent(result);
+  });
+  server.tool("create_course_draft_from_course", createCourseDraftFromCourseShape, async (args) => {
+    const payload = ZCourseImportDraftCreateFromCourse.parse(args);
+    const result = await apiClient.createCourseDraftFromCourse(payload);
+    return jsonContent(result);
+  });
+  server.tool("get_course_draft", getCourseDraftShape, async (args) => {
+    const { draftId } = ZCourseImportDraftGetParam.parse(args);
+    const result = await apiClient.getCourseDraft(draftId);
+    return jsonContent(result);
+  });
+  server.tool("update_course_draft", updateCourseDraftShape, async (args) => {
+    const { draftId, ...payload } = ZUpdateCourseDraftToolInput.parse(args);
+    const result = await apiClient.updateCourseDraft(draftId, payload);
+    return jsonContent(result);
+  });
+  server.tool("publish_course_draft", publishCourseDraftShape, async (args) => {
+    const { draftId, ...payload } = ZPublishCourseDraftToolInput.parse(args);
+    const result = await apiClient.publishCourseDraft(draftId, payload);
+    return jsonContent(result);
+  });
+  server.tool("publish_course_draft_to_existing_course", publishCourseDraftToExistingCourseShape, async (args) => {
+    const { draftId, ...payload } = ZPublishCourseDraftToExistingCourseToolInput.parse(args);
+    const result = await apiClient.publishCourseDraftToExistingCourse(draftId, payload);
+    return jsonContent(result);
+  });
+}
+function jsonContent(data) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(data)
+      }
+    ]
+  };
+}
+
+// src/index.ts
+async function main() {
+  const config = getConfig();
+  const apiClient = new ClassroomIoApiClient(config);
+  const server = new McpServer({
+    name: "classroomio-course-authoring",
+    version: "0.0.1"
+  });
+  registerCourseDraftTools(server, apiClient);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  process.stdin.on("close", () => {
+    void server.close();
+  });
+}
+main().catch((error) => {
+  if (error instanceof ClassroomIoApiError) {
+    console.error(
+      JSON.stringify({
+        error: error.message,
+        status: error.status,
+        code: error.code,
+        field: error.field
+      })
+    );
+    process.exit(1);
+  }
+  console.error(error);
+  process.exit(1);
+});