quiz-mcp 0.0.1

package/dist/cli.js

@@ -0,0 +1,805 @@
+// src/cli/cli.ts
+import { readFileSync, writeFileSync, existsSync as existsSync2 } from "node:fs";
+import { join as join2, dirname as dirname2 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { Command } from "commander";
+import openFn from "open";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+
+// src/server/index.ts
+import { createServer } from "node:http";
+
+// src/lib/server/sessions.ts
+var SessionStore = class {
+  sessions = /* @__PURE__ */ new Map();
+  sessionDurationMs;
+  storagePath;
+  constructor(options = {}) {
+    const durationMinutes = options.sessionDurationMinutes || 60;
+    this.sessionDurationMs = durationMinutes * 60 * 1e3;
+    this.storagePath = options.storagePath;
+    if (typeof setInterval !== "undefined") {
+      setInterval(() => this.cleanup(), 6e4);
+    }
+  }
+  /**
+   * Generate a unique ID
+   */
+  generateId(prefix) {
+    return `${prefix}-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+  }
+  /**
+   * Create a new quiz session
+   */
+  createSession(quiz, config = {}, customSessionId) {
+    const quizId = this.generateId("quiz");
+    const sessionId = customSessionId || this.generateId("session");
+    const now = /* @__PURE__ */ new Date();
+    const expiresAt = new Date(now.getTime() + this.sessionDurationMs);
+    const session = {
+      quizId,
+      sessionId,
+      quiz,
+      config,
+      status: "active",
+      startedAt: now.toISOString(),
+      expiresAt: expiresAt.toISOString()
+    };
+    this.sessions.set(`${quizId}:${sessionId}`, session);
+    return session;
+  }
+  /**
+   * Get a session by quiz ID and session ID
+   */
+  getSession(quizId, sessionId) {
+    const key = `${quizId}:${sessionId}`;
+    const session = this.sessions.get(key);
+    if (session) {
+      if (new Date(session.expiresAt) < /* @__PURE__ */ new Date()) {
+        session.status = "expired";
+        this.sessions.delete(key);
+        return void 0;
+      }
+    }
+    return session;
+  }
+  /**
+   * Get session by full key
+   */
+  getSessionByKey(key) {
+    const session = this.sessions.get(key);
+    if (!session) return void 0;
+    if (new Date(session.expiresAt) < /* @__PURE__ */ new Date()) {
+      session.status = "expired";
+      this.sessions.delete(key);
+      return void 0;
+    }
+    return session;
+  }
+  /**
+   * Update session status
+   */
+  updateStatus(quizId, sessionId, status) {
+    const session = this.getSession(quizId, sessionId);
+    if (!session) return void 0;
+    session.status = status;
+    if (status === "completed") {
+      session.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+    } else if (status === "expired") {
+      session.completedAt = session.completedAt || (/* @__PURE__ */ new Date()).toISOString();
+    }
+    return session;
+  }
+  /**
+   * Save answers to session
+   */
+  saveAnswers(quizId, sessionId, answers) {
+    const session = this.getSession(quizId, sessionId);
+    if (!session || session.status !== "active") return void 0;
+    session.answers = answers;
+    return session;
+  }
+  /**
+   * Complete session with results
+   */
+  completeSession(quizId, sessionId, results) {
+    const session = this.getSession(quizId, sessionId);
+    if (!session) return void 0;
+    session.status = "completed";
+    session.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+    session.results = results;
+    return session;
+  }
+  /**
+   * Cancel session
+   */
+  cancelSession(quizId, sessionId, reason) {
+    const session = this.getSession(quizId, sessionId);
+    if (!session || session.status !== "active") return void 0;
+    session.status = "completed";
+    session.cancelledAt = (/* @__PURE__ */ new Date()).toISOString();
+    session.cancelReason = reason;
+    return session;
+  }
+  /**
+   * Get all active sessions
+   */
+  getActiveSessions() {
+    const now = /* @__PURE__ */ new Date();
+    return Array.from(this.sessions.values()).filter(
+      (s) => s.status === "active" && new Date(s.expiresAt) > now
+    );
+  }
+  /**
+   * Get session count
+   */
+  getSessionCount() {
+    const now = /* @__PURE__ */ new Date();
+    const active = Array.from(this.sessions.values()).filter(
+      (s) => s.status === "active" && new Date(s.expiresAt) > now
+    ).length;
+    return { active, total: this.sessions.size };
+  }
+  /**
+   * Clean up expired sessions
+   */
+  cleanup() {
+    const now = /* @__PURE__ */ new Date();
+    let removed = 0;
+    for (const [key, session] of this.sessions.entries()) {
+      if (new Date(session.expiresAt) < now) {
+        session.status = "expired";
+        this.sessions.delete(key);
+        removed++;
+      }
+    }
+    return removed;
+  }
+  /**
+   * Clear all sessions
+   */
+  clear() {
+    this.sessions.clear();
+  }
+};
+var globalStore = null;
+function getSessionStore() {
+  const globalKey = "quiz-mcp-session-store";
+  const existingStore = globalThis[globalKey];
+  if (existingStore) {
+    return existingStore;
+  }
+  if (!globalStore) {
+    globalStore = new SessionStore();
+  }
+  globalThis[globalKey] = globalStore;
+  return globalStore;
+}
+
+// src/server/index.ts
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { getRequest, setResponse } from "@sveltejs/kit/node";
+import { existsSync, createReadStream } from "node:fs";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var serverInstance = null;
+async function getServer() {
+  if (serverInstance === null) {
+    const buildDir = join(__dirname, "server");
+    const serverModule = await import(`${buildDir}/index.js`);
+    const manifestModule = await import(`${buildDir}/manifest.js`);
+    const server = new serverModule.Server(manifestModule.manifest);
+    await server.init({
+      env: process.env,
+      read: (file) => {
+        const stream = createReadStream(join(__dirname, "client", file));
+        return stream;
+      }
+    });
+    serverInstance = server;
+  }
+  return serverInstance;
+}
+function calculateProgress(session) {
+  const total = session.quiz.questions.length;
+  const answered = session.answers?.size || 0;
+  return { answered, total, percentage: total > 0 ? Math.round(answered / total * 100) : 0 };
+}
+async function createRequestHandler(server) {
+  const buildDir = join(__dirname, "server");
+  const clientDir = join(__dirname, "client");
+  const serveStaticFile = async (req, res) => {
+    const url = req.url || "";
+    if (!url.startsWith("/_app/")) {
+      return false;
+    }
+    const filePath = join(clientDir, url);
+    try {
+      if (!existsSync(filePath)) {
+        res.writeHead(404);
+        res.end("Not Found");
+        return true;
+      }
+      const ext = url.split(".").pop()?.toLowerCase();
+      const contentTypes = {
+        js: "application/javascript",
+        css: "text/css",
+        json: "application/json",
+        png: "image/png",
+        jpg: "image/jpeg",
+        gif: "image/gif",
+        svg: "image/svg+xml",
+        woff: "font/woff",
+        woff2: "font/woff2",
+        ico: "image/x-icon"
+      };
+      const contentType = contentTypes[ext || ""] || "application/octet-stream";
+      res.writeHead(200, {
+        "Content-Type": contentType,
+        "Cache-Control": "public, max-age=31536000, immutable"
+      });
+      const stream = createReadStream(filePath);
+      stream.pipe(res);
+      return true;
+    } catch (error) {
+      console.error("Static file error:", error);
+      res.writeHead(500);
+      res.end("Internal Server Error");
+      return true;
+    }
+  };
+  return async (req, res) => {
+    const ip = req.headers["x-forwarded-for"]?.toString() || req.socket.remoteAddress?.replace("::ffff:", "") || "127.0.0.1";
+    try {
+      const wasStatic = await serveStaticFile(req, res);
+      if (wasStatic) return;
+      const origin = `http://${req.headers.host}`;
+      const request = await getRequest({
+        base: origin,
+        request: req
+      });
+      const response = await server.respond(request, {
+        platform: { req },
+        getClientAddress: () => ip
+      });
+      await setResponse(res, response);
+    } catch (error) {
+      console.error("Request error:", error);
+      res.writeHead(500, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Internal server error" }));
+    }
+  };
+}
+async function createQuizServer(options = {}) {
+  const port = options.port || Number(process.env.PORT) || Number(process.env.QUIZ_PORT) || 3e3;
+  const host = options.host || process.env.HOST || process.env.QUIZ_HOST || "localhost";
+  if (options.configPath) {
+    process.env.QUIZ_CONFIG = options.configPath;
+  }
+  const sessionStore = getSessionStore();
+  const server = await getServer();
+  const requestHandler = await createRequestHandler(server);
+  const httpServer = createServer(requestHandler);
+  let serverUrl = "";
+  let isStarted = false;
+  const quizServer = {
+    server: httpServer,
+    get url() {
+      return serverUrl;
+    },
+    port,
+    host,
+    async start() {
+      if (isStarted) return;
+      await new Promise((resolve, reject) => {
+        httpServer.on("error", reject);
+        httpServer.listen(port, "127.0.0.1", () => {
+          isStarted = true;
+          const address = httpServer.address();
+          serverUrl = `http://127.0.0.1:${address.port}`;
+          resolve();
+        });
+      });
+      options.onReady?.(serverUrl);
+    },
+    async stop() {
+      return new Promise((resolve) => {
+        httpServer.close(() => resolve());
+      });
+    },
+    async createSession(quiz, config, open, customSessionId) {
+      const session = sessionStore.createSession(quiz, config || {}, customSessionId);
+      const quizUrl = `${serverUrl}/${session.quizId}/${session.sessionId}`;
+      return {
+        quizId: session.quizId,
+        sessionId: session.sessionId,
+        url: open !== false ? quizUrl : "",
+        expiresAt: session.expiresAt
+      };
+    },
+    async getSessionStatus(quizId, sessionId, includeAnswers) {
+      const session = sessionStore.getSession(quizId, sessionId);
+      if (!session) {
+        return { status: "not_found", startedAt: "" };
+      }
+      if (session.status === "expired") {
+        return {
+          status: "expired",
+          startedAt: session.startedAt,
+          completedAt: session.completedAt
+        };
+      }
+      if (includeAnswers && session.results) {
+        return {
+          status: session.status,
+          startedAt: session.startedAt,
+          completedAt: session.completedAt,
+          progress: calculateProgress(session),
+          answers: session.results
+        };
+      }
+      return {
+        status: session.status,
+        startedAt: session.startedAt,
+        completedAt: session.completedAt,
+        progress: calculateProgress(session)
+      };
+    },
+    async cancelSession(quizId, sessionId, reason) {
+      const session = sessionStore.cancelSession(quizId, sessionId, reason);
+      if (!session) {
+        return { ok: false, message: "Session not found or already completed", cancelledAt: "" };
+      }
+      return {
+        ok: true,
+        message: reason || "Session cancelled",
+        cancelledAt: session.cancelledAt || (/* @__PURE__ */ new Date()).toISOString()
+      };
+    }
+  };
+  return quizServer;
+}
+
+// src/cli/cli.ts
+var __dirname2 = dirname2(fileURLToPath2(import.meta.url));
+var QuestionTypeSchema = z.enum(["single", "multiple", "remove-extra", "order", "match", "text"]);
+var QuestionSchema = z.object({
+  id: z.string(),
+  type: QuestionTypeSchema,
+  question: z.string(),
+  explanation: z.string().optional(),
+  options: z.array(z.string()).optional(),
+  points: z.number().optional(),
+  required: z.boolean().optional()
+});
+var QuizDataSchema = z.object({
+  title: z.string().optional(),
+  description: z.string().optional(),
+  version: z.string().optional(),
+  metadata: z.object({
+    author: z.string().optional(),
+    difficulty: z.enum(["easy", "medium", "hard"]).optional(),
+    estimatedTime: z.number().optional(),
+    tags: z.array(z.string()).optional()
+  }).optional(),
+  questions: z.array(QuestionSchema).min(1)
+});
+var QuizConfigSchema = z.object({
+  theme: z.enum(["light", "dark", "auto"]).optional(),
+  shuffleQuestions: z.boolean().optional(),
+  shuffleOptions: z.boolean().optional(),
+  timerEnabled: z.boolean().optional(),
+  timerDuration: z.number().optional()
+}).optional();
+function loadConfig(path) {
+  if (!path) return void 0;
+  try {
+    const content = readFileSync(path, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    throw new Error(`Failed to load config file: ${path}
+${error}`);
+  }
+}
+function loadMCPConfig(path) {
+  if (!path) return void 0;
+  try {
+    const content = readFileSync(path, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    throw new Error(`Failed to load MCP config file: ${path}
+${error}`);
+  }
+}
+function loadQuiz(source, file) {
+  if (file) {
+    try {
+      const content = readFileSync(file, "utf-8");
+      return JSON.parse(content);
+    } catch (error) {
+      throw new Error(`Failed to load quiz file: ${file}
+${error}`);
+    }
+  }
+  if (source) {
+    try {
+      return JSON.parse(source);
+    } catch {
+      throw new Error("Invalid quiz JSON. Provide valid JSON with --quiz flag.");
+    }
+  }
+  throw new Error("No quiz provided. Use --file <path> or --quiz <json>");
+}
+async function waitForServer(server, timeout = 3e4) {
+  const start = Date.now();
+  while (Date.now() - start < timeout) {
+    try {
+      const response = await fetch(`${server.url}/api/quiz`, { method: "GET" });
+      if (response.ok) return;
+    } catch {
+    }
+    await new Promise((r) => setTimeout(r, 500));
+  }
+  throw new Error("Server failed to start");
+}
+async function pollForResults(server, quizId, sessionId, interval = 1e3) {
+  while (true) {
+    try {
+      const status = await server.getSessionStatus(quizId, sessionId);
+      if (status.status === "completed" || status.status === "not_found") {
+        break;
+      }
+    } catch {
+    }
+    await new Promise((r) => setTimeout(r, interval));
+  }
+}
+async function ensureBuildExists() {
+  const entry = join2(__dirname2, "index.js");
+  if (!existsSync2(entry)) {
+    console.log("Building quiz-mcp...");
+    const { spawn } = await import("node:child_process");
+    await new Promise((resolve, reject) => {
+      const proc = spawn("pnpm", ["run", "build"], { stdio: "inherit" });
+      proc.on("close", (code) => {
+        if (code === 0) resolve();
+        else reject(new Error(`Build failed with exit code ${code}`));
+      });
+      proc.on("error", reject);
+    });
+  }
+}
+async function runRunnerMode(args) {
+  const quiz = loadQuiz(args.quiz, args.file);
+  const config = loadConfig(args.config);
+  const port = Number(args.port) || parseInt(process.env.QUIZ_PORT || "3000", 10);
+  const host = args.host ? String(args.host) : process.env.QUIZ_HOST || "localhost";
+  const shouldOpen = args.open === true || args.open === "true" || process.env.QUIZ_OPEN === "true";
+  const outputPath = args.output ? String(args.output) : process.env.QUIZ_OUTPUT || void 0;
+  const webhookUrl = args.webhook ? String(args.webhook) : config?.webhook || process.env.QUIZ_WEBHOOK || void 0;
+  const configPath = args.config ? String(args.config) : process.env.QUIZ_CONFIG;
+  if (configPath) {
+    process.env.QUIZ_CONFIG = configPath;
+  }
+  await ensureBuildExists();
+  console.log(`Starting quiz server at http://${host}:${port}`);
+  const server = await createQuizServer({
+    port,
+    host,
+    configPath,
+    onReady: (url) => console.log(`Server ready at ${url}`)
+  });
+  await server.start();
+  await waitForServer(server);
+  const session = await server.createSession(quiz, config, true);
+  console.log(`Quiz session created: ${session.quizId}/${session.sessionId}`);
+  console.log(`Quiz URL: ${session.url}`);
+  if (shouldOpen) {
+    await openFn(session.url);
+    console.log("Browser opened");
+  }
+  console.log("Waiting for quiz completion...");
+  await pollForResults(server, session.quizId, session.sessionId);
+  const status = await server.getSessionStatus(session.quizId, session.sessionId, true);
+  if (status.answers) {
+    const results = status.answers;
+    if (outputPath) {
+      writeFileSync(outputPath, JSON.stringify(results, null, 2));
+      console.log(`Results saved to: ${outputPath}`);
+    }
+    if (webhookUrl) {
+      try {
+        await fetch(webhookUrl, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(results)
+        });
+        console.log(`Results sent to webhook: ${webhookUrl}`);
+      } catch (error) {
+        console.error(`Failed to send to webhook: ${error}`);
+      }
+    }
+    console.log("\nQuiz Results:");
+    console.log(`  Total Questions: ${results.summary.totalQuestions}`);
+    console.log(`  Answered: ${results.summary.answeredQuestions}`);
+    console.log(
+      `  Required Answered: ${results.summary.requiredAnswered}/${results.summary.requiredQuestions}`
+    );
+    console.log(`  Time Spent: ${results.metadata.timeSpent}s`);
+  }
+  console.log("\nShutting down server...");
+  await server.stop();
+  console.log("Done!");
+  process.exit(0);
+}
+async function runMCPMode(mcpConfig, args) {
+  const port = Number(args.port) || mcpConfig?.port || Number(process.env.QUIZ_PORT ?? "3000");
+  const host = String(args.host ?? mcpConfig?.host ?? process.env.QUIZ_HOST ?? "localhost");
+  const quizConfigPath = args.quizConfig;
+  const baseUrl = `http://${host}:${port}`;
+  console.error(`Starting quiz server at ${baseUrl}`);
+  await ensureBuildExists();
+  const server = await createQuizServer({
+    port,
+    host,
+    configPath: quizConfigPath,
+    onReady: (url) => console.error(`Quiz server ready at ${url}`)
+  });
+  await server.start();
+  await waitForServer(server);
+  console.error("Quiz server is ready");
+  const mcpServer = new McpServer({ name: "quiz-mcp", version: "1.0.0" });
+  mcpServer.registerTool(
+    "get_quiz_format",
+    {
+      title: "Quiz Schema Format",
+      description: "Get the quiz JSON schema and examples for AI agents",
+      inputSchema: z.object({})
+    },
+    async () => {
+      const examples = [
+        {
+          type: "single",
+          example: {
+            id: "q1",
+            type: "single",
+            question: "Capital of France?",
+            options: ["London", "Paris"],
+            points: 1
+          },
+          description: "Single choice"
+        },
+        {
+          type: "multiple",
+          example: {
+            id: "q2",
+            type: "multiple",
+            question: "Which are programming languages?",
+            options: ["Python", "Java", "HTML", "JavaScript"],
+            points: 2
+          },
+          description: "Multiple choice"
+        },
+        {
+          type: "text",
+          example: {
+            id: "q3",
+            type: "text",
+            question: "Explain in your own words what is MCP"
+          },
+          description: "Open text answer"
+        }
+      ];
+      const payload = {
+        schema: QuizDataSchema.shape,
+        examples,
+        version: "1.0.0"
+      };
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(payload, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  mcpServer.registerTool(
+    "start_quiz",
+    {
+      title: "Start Quiz",
+      description: "Start a new quiz session from provided quiz data",
+      inputSchema: z.object({
+        quiz: z.union([z.string(), QuizDataSchema]),
+        config: QuizConfigSchema,
+        open: z.boolean().optional().describe("Open browser after quiz start").default(false)
+      })
+    },
+    async ({ quiz, config, open }) => {
+      let quizData;
+      try {
+        quizData = typeof quiz === "string" ? QuizDataSchema.parse(JSON.parse(quiz)) : QuizDataSchema.parse(quiz);
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Invalid quiz format: ${String(err)}` }],
+          isError: true
+        };
+      }
+      try {
+        const response = await server.createSession(quizData, config);
+        const url = `${server.url}/${response.quizId}/${response.sessionId}`;
+        if (open) {
+          await openFn(url);
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  ok: true,
+                  openUrl: url,
+                  quizId: response.quizId,
+                  sessionId: response.sessionId,
+                  expiresAt: response.expiresAt
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Failed to create quiz session: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+  mcpServer.registerTool(
+    "get_quiz_status",
+    {
+      title: "Get Quiz Status",
+      description: "Check the status of a quiz session",
+      inputSchema: z.object({
+        quizId: z.string(),
+        sessionId: z.string(),
+        includeAnswers: z.boolean().optional().default(false)
+      })
+    },
+    async ({ quizId, sessionId, includeAnswers }) => {
+      try {
+        const status = await server.getSessionStatus(quizId, sessionId, includeAnswers);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(status, null, 2)
+            }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  status: "error",
+                  startedAt: "",
+                  error: `Failed to get status: ${err instanceof Error ? err.message : String(err)}`
+                },
+                null,
+                2
+              )
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+  mcpServer.registerTool(
+    "cancel_quiz",
+    {
+      title: "Cancel Quiz",
+      description: "Cancel an active quiz session",
+      inputSchema: z.object({
+        quizId: z.string(),
+        sessionId: z.string(),
+        reason: z.string().optional()
+      })
+    },
+    async ({ quizId, sessionId, reason }) => {
+      try {
+        const response = await server.cancelSession(quizId, sessionId, reason);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(response, null, 2)
+            }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  ok: false,
+                  message: "",
+                  cancelledAt: "",
+                  error: `Failed to cancel: ${err instanceof Error ? err.message : String(err)}`
+                },
+                null,
+                2
+              )
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+  const transport = new StdioServerTransport();
+  await mcpServer.connect(transport);
+  const shutdown = async (signal) => {
+    console.error(`
+${signal}, shutting down...`);
+    await server.stop();
+    process.exit(0);
+  };
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+  process.on("SIGINT", () => shutdown("SIGINT"));
+}
+async function main(argv) {
+  const scriptName = argv[1] || "quiz";
+  const programName = scriptName.includes("quiz-runner-mcp") ? "quiz-runner-mcp" : scriptName.includes("quiz-runner") ? "quiz-runner" : "quiz";
+  const program = new Command();
+  program.name(programName).description("Quiz MCP - Interactive quiz runner and MCP server");
+  program.option("-p, --port <NUMBER>", "Server port (default: 3000)");
+  program.option("-h, --host <STRING>", "Server host (default: localhost)");
+  program.option("-v, --verbose", "Verbose logging");
+  const runnerCmd = program.command("run").description("Run interactive quizzes via CLI with browser interface").option("-f, --file <PATH>", "Path to quiz JSON file").option("-q, --quiz <JSON>", "Direct JSON quiz data").option("-c, --config <PATH>", "Path to configuration file").option("-o, --output <PATH>", "Output results file path").option("-w, --webhook-url <URL>", "Webhook URL for results").option("-O, --open", "Auto-open browser");
+  runnerCmd.action(async (opts) => {
+    try {
+      await runRunnerMode(opts);
+    } catch (error) {
+      console.error(`Error: ${error instanceof Error ? error.message : error}`);
+      process.exit(1);
+    }
+  });
+  const mcpCmd = program.command("mcp").description("Run as MCP server for AI agent integration").option("-c, --config <PATH>", "MCP configuration file path").option(
+    "--quiz-config <PATH>",
+    "Quiz configuration file path (layout, theme, language, webhook)"
+  ).option("-s, --storage <PATH>", "Session storage directory").option("-m, --max-sessions <NUMBER>", "Maximum concurrent sessions").option("-q, --quiz <PATH>", "Default quiz file path").option("-l, --log-level <LEVEL>", "Log level (debug, info, warn, error)");
+  mcpCmd.action(async (opts) => {
+    try {
+      const configPath = opts.config;
+      const config = loadMCPConfig(configPath);
+      await runMCPMode(config, opts);
+    } catch (err) {
+      console.error(`Fatal error: ${err instanceof Error ? err.message : String(err)}`);
+      process.exit(1);
+    }
+  });
+  program.parse(argv);
+}
+main(process.argv).catch((err) => {
+  console.error("Unhandled error:", err);
+  process.exit(1);
+});
+export {
+  main
+};