kiku-agent 1.0.0

package/server/mcp/handler.js

@@ -0,0 +1,159 @@
+import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { createMcpServer } from './server.js';
+import { checkRateLimit, validateSessionId, securityMiddleware, MAX_REQUEST_BODY_SIZE } from './security.js';
+
+const sessions = new Map();
+const SESSION_TTL_MS = 30 * 60_000;
+const MAX_SESSIONS = 100;
+
+function sendJson(res, statusCode, payload, headers = {}) {
+  if (res.headersSent) return;
+  res.statusCode = statusCode;
+  res.setHeader('Content-Type', 'application/json; charset=utf-8');
+  for (const [name, value] of Object.entries(headers)) res.setHeader(name, value);
+  res.end(JSON.stringify(payload));
+}
+
+async function closeSession(sessionId) {
+  const session = sessions.get(sessionId);
+  if (!session) return;
+  sessions.delete(sessionId);
+  clearInterval(session.heartbeat);
+  await Promise.allSettled([session.transport.close(), session.server.close()]);
+}
+
+function cleanupSessions() {
+  const now = Date.now();
+  for (const [id, session] of sessions) {
+    if (now - session.lastSeen > SESSION_TTL_MS) void closeSession(id);
+  }
+  if (sessions.size > MAX_SESSIONS) {
+    const excess = [...sessions.entries()]
+      .sort((a, b) => a[1].lastSeen - b[1].lastSeen)
+      .slice(0, sessions.size - MAX_SESSIONS);
+    for (const [id] of excess) void closeSession(id);
+  }
+}
+
+function validateRequestSize(req, res) {
+  const contentLength = Number.parseInt(req.headers['content-length'] || '0', 10);
+  if (Number.isFinite(contentLength) && contentLength > MAX_REQUEST_BODY_SIZE) {
+    sendJson(res, 413, { error: 'Request body too large.' }, { 'Retry-After': '60' });
+    return false;
+  }
+  return true;
+}
+
+export async function handleMcpSse(req, res) {
+  cleanupSessions();
+  const security = securityMiddleware(req, res);
+  if (security.blocked) return;
+
+  const transport = new SSEServerTransport('/api/v1/mcp/message', res);
+  const sessionId = transport.sessionId;
+  const server = createMcpServer();
+  const session = {
+    server,
+    transport,
+    createdAt: Date.now(),
+    lastSeen: Date.now(),
+    messageCount: 0,
+    heartbeat: null,
+  };
+
+  sessions.set(sessionId, session);
+  transport.onclose = () => { void closeSession(sessionId); };
+  transport.onerror = error => console.error(`MCP SSE transport [${sessionId}]: ${error.message}`);
+
+  try {
+    await server.connect(transport);
+    session.heartbeat = setInterval(() => {
+      if (!res.writableEnded) res.write(': keep-alive\n\n');
+    }, 15_000);
+    session.heartbeat.unref?.();
+  } catch (error) {
+    await closeSession(sessionId);
+    if (!res.headersSent) sendJson(res, 500, { error: 'Unable to establish MCP SSE transport.' });
+    throw error;
+  }
+}
+
+export async function handleMcpMessage(req, res) {
+  const security = securityMiddleware(req, res);
+  if (security.blocked || !validateRequestSize(req, res)) return;
+
+  const url = new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`);
+  const sessionId = url.searchParams.get('sessionId');
+  if (!sessionId || !validateSessionId(sessionId)) {
+    return sendJson(res, 400, { error: 'Invalid or missing sessionId.' });
+  }
+
+  const session = sessions.get(sessionId);
+  if (!session) {
+    return sendJson(res, 404, { error: 'Session not found or expired. Reconnect through /api/v1/mcp/sse.' });
+  }
+
+  const rate = checkRateLimit(`mcp:${sessionId}`);
+  if (!rate.allowed) {
+    return sendJson(res, 429, { error: rate.error }, { 'Retry-After': '60' });
+  }
+  res.setHeader('X-RateLimit-Remaining', String(rate.remaining));
+
+  session.messageCount++;
+  session.lastSeen = Date.now();
+  if (session.messageCount > 500) {
+    await closeSession(sessionId);
+    return sendJson(res, 429, { error: 'Session message limit reached. Reconnect to create a new session.' });
+  }
+
+  await session.transport.handlePostMessage(req, res);
+}
+
+export async function handleMcpHttp(req, res) {
+  const security = securityMiddleware(req, res);
+  if (security.blocked || !validateRequestSize(req, res)) return;
+
+  if (req.method !== 'POST') {
+    res.setHeader('Allow', 'POST, OPTIONS');
+    return sendJson(res, 405, {
+      jsonrpc: '2.0',
+      error: { code: -32000, message: 'Method not allowed. Use POST for Streamable HTTP.' },
+      id: null,
+    });
+  }
+
+  const rate = checkRateLimit(`mcp-http:${req.socket?.remoteAddress || 'unknown'}`);
+  if (!rate.allowed) return sendJson(res, 429, { error: rate.error }, { 'Retry-After': '60' });
+  res.setHeader('X-RateLimit-Remaining', String(rate.remaining));
+
+  const server = createMcpServer();
+  const transport = new StreamableHTTPServerTransport({
+    sessionIdGenerator: undefined,
+    enableJsonResponse: true,
+  });
+
+  try {
+    await server.connect(transport);
+    await transport.handleRequest(req, res);
+  } catch (error) {
+    console.error(`MCP Streamable HTTP: ${error.message}`);
+    sendJson(res, 500, {
+      jsonrpc: '2.0',
+      error: { code: -32603, message: 'Internal MCP server error.' },
+      id: null,
+    });
+  } finally {
+    await Promise.allSettled([transport.close(), server.close()]);
+  }
+}
+
+export function getMcpSessionStats() {
+  return { activeSessions: sessions.size, maxSessions: MAX_SESSIONS, ttlMs: SESSION_TTL_MS };
+}
+
+export function isMcpRoute(pathname) {
+  return pathname === '/api/v1/mcp'
+    || pathname === '/api/v1/mcp/sse'
+    || pathname === '/api/v1/mcp/message';
+}

package/server/mcp/prompts.js

@@ -0,0 +1,143 @@
+import { worksData, timelineData, profileData, brandsData } from './data/index.js';
+
+export const promptDefinitions = [
+  {
+    name: 'recommend_series',
+    description: 'Recommend Ju Jingyi dramas based on mood, genre preference, or viewing style.',
+    arguments: [
+      { name: 'mood', description: 'Current mood (romantic, action-packed, mysterious, emotional, lighthearted)', required: false },
+      { name: 'genre', description: 'Preferred genre (historical, fantasy, xianxia, romance, suspense)', required: false },
+    ],
+  },
+  {
+    name: 'character_summary',
+    description: 'Get a detailed summary of a specific character role and its development.',
+    arguments: [
+      { name: 'character_name', description: 'Name of the character (e.g. "Yang Caiwei", "Bai Suzhen", "Lu Wuyi", "Han Yunxi")', required: true },
+    ],
+  },
+  {
+    name: 'career_overview',
+    description: 'Get a comprehensive career overview with key milestones organized by era.',
+    arguments: [],
+  },
+  {
+    name: 'brand_portfolio',
+    description: 'Get a summary of Ju Jingyi\'s brand endorsement portfolio and commercial influence.',
+    arguments: [],
+  },
+];
+
+function recommendSeries({ mood, genre } = {}) {
+  const moodGenreMap = {
+    romantic: ['historical-drama'],
+    emotional: ['historical-drama', 'fantasy-drama'],
+    'action-packed': ['xianxia-drama', 'fantasy-drama'],
+    mysterious: ['historical-drama'],
+    lighthearted: ['historical-drama'],
+  };
+
+  const preferredCategories = mood ? (moodGenreMap[mood.toLowerCase()] || []) : [];
+  let candidates = [...worksData];
+
+  if (genre) {
+    candidates = candidates.filter(w => w.category.toLowerCase().includes(genre.toLowerCase()));
+  }
+  if (preferredCategories.length > 0) {
+    candidates = candidates.filter(w => preferredCategories.includes(w.category));
+  }
+
+  candidates.sort((a, b) => (b.featured ? 1 : 0) - (a.featured ? 1 : 0) || b.year - a.year);
+  const top = candidates.slice(0, 5);
+
+  return {
+    messages: [{
+      role: 'user',
+      content: {
+        type: 'text',
+        text: `Recommend Ju Jingyi dramas${mood ? ` for mood: "${mood}"` : ''}${genre ? `, genre: "${genre}"` : ''}.\n\nHere are the best matches:\n\n${top.map((w, i) => `${i + 1}. **${w.titleEn}** (${w.titleCn}, ${w.year})\n   Role: ${w.role}\n   Platform: ${w.platform || 'TBA'}\n   ${w.synopsis ? w.synopsis.slice(0, 150) + '...' : ''}\n`).join('\n')}\n\nBased on your preference${mood ? ` for "${mood}" content` : ''}, I recommend starting with the top suggestion.`,
+      },
+    }],
+  };
+}
+
+function characterSummary({ character_name }) {
+  const q = character_name.toLowerCase();
+  const matches = worksData.filter(w => w.role.toLowerCase().includes(q));
+  if (matches.length === 0) {
+    return {
+      messages: [{
+        role: 'user',
+        content: { type: 'text', text: `No character matching "${character_name}" found. Available characters: ${worksData.map(w => w.role.split(' (')[0]).join(', ')}` },
+      }],
+    };
+  }
+
+  const summaries = matches.map(w =>
+    `**${w.role}** in **${w.titleEn}** (${w.titleCn}, ${w.year})\nPlatform: ${w.platform || 'TBA'}\n${w.synopsis || 'No synopsis available.'}`
+  ).join('\n\n');
+
+  return {
+    messages: [{
+      role: 'user',
+      content: { type: 'text', text: `Character Summary: "${character_name}"\n\nJu Jingyi portrayed this role${matches.length > 1 ? ` (${matches.length} appearances)` : ''}:\n\n${summaries}` },
+    }],
+  };
+}
+
+function careerOverview() {
+  const eras = {};
+  for (const t of timelineData) {
+    if (!eras[t.era]) eras[t.era] = [];
+    eras[t.era].push(t);
+  }
+
+  let overview = `# Ju Jingyi Career Overview\n\n${profileData.bioSummary}\n\n`;
+  overview += `**Fandom:** ${profileData.details.fandomName} | **Colors:** ${profileData.details.fandomColors}\n\n`;
+  overview += `## Career Eras\n\n`;
+
+  for (const [era, events] of Object.entries(eras)) {
+    overview += `### ${era}\n`;
+    for (const e of events.sort((a, b) => a.year - b.year)) {
+      overview += `- **${e.year}**: ${e.title} (${e.titleCn}) — ${e.summary}\n`;
+    }
+    overview += '\n';
+  }
+
+  return { messages: [{ role: 'user', content: { type: 'text', text: overview } }] };
+}
+
+function brandPortfolio() {
+  const globalBrands = brandsData.filter(b => b.isGlobal);
+  const otherBrands = brandsData.filter(b => !b.isGlobal);
+
+  let text = `# Ju Jingyi Brand Endorsement Portfolio\n\n`;
+  text += `**Title:** ${brandsData.length}+ brand partnerships | "Commercial Harvest Machine" (商务收割机)\n\n`;
+
+  text += `## Global Brand Ambassadors\n`;
+  for (const b of globalBrands) {
+    text += `- **${b.brandNameEn}** (${b.brandNameCn}) — ${b.title} (${b.year})\n  Category: ${b.category}\n  Highlight: ${b.highlight}\n\n`;
+  }
+
+  text += `## Other Endorsements\n`;
+  for (const b of otherBrands) {
+    text += `- **${b.brandNameEn}** (${b.brandNameCn}) — ${b.title} (${b.year})\n  ${b.highlight}\n`;
+  }
+
+  return { messages: [{ role: 'user', content: { type: 'text', text } }] };
+}
+
+// ── Dispatch ──
+
+const promptHandlers = {
+  recommend_series: recommendSeries,
+  character_summary: characterSummary,
+  career_overview: careerOverview,
+  brand_portfolio: brandPortfolio,
+};
+
+export async function getPrompt(name, args = {}) {
+  const handler = promptHandlers[name];
+  if (!handler) throw new Error(`Unknown prompt: ${name}`);
+  return handler(args);
+}

package/server/mcp/resources.js

@@ -0,0 +1,54 @@
+import { profileData, worksData, discographyData, awardsData, timelineData, brandsData } from './data/index.js';
+
+export const resourceDefinitions = [
+  { uri: 'kiku://bio', name: 'Ju Jingyi Biography', description: 'Full biographical profile, talents, quotes, and social media links.', mimeType: 'application/json' },
+  { uri: 'kiku://awards', name: 'Awards & Honors', description: 'Complete list of awards, honors, and recognitions.', mimeType: 'application/json' },
+  { uri: 'kiku://catalog', name: 'Works Catalog Summary', description: 'Summary of all works, songs, awards, and milestones.', mimeType: 'application/json' },
+  { uri: 'kiku://timeline', name: 'Career Timeline', description: 'Full chronological career timeline from 2013 to present.', mimeType: 'application/json' },
+  { uri: 'kiku://discography', name: 'Discography', description: 'Complete discography with YouTube links.', mimeType: 'application/json' },
+  { uri: 'kiku://brands', name: 'Brand Endorsements', description: 'All brand endorsements and ambassadorships.', mimeType: 'application/json' },
+  { uri: 'kiku://social', name: 'Social Media Links', description: 'Official social media accounts and links.', mimeType: 'application/json' },
+];
+
+export async function readResource(uri) {
+  switch (uri) {
+    case 'kiku://bio':
+      return { contents: [{ uri, mimeType: 'application/json', text: JSON.stringify(profileData, null, 2) }] };
+
+    case 'kiku://awards':
+      return { contents: [{ uri, mimeType: 'application/json', text: JSON.stringify(awardsData.sort((a, b) => b.year - a.year), null, 2) }] };
+
+    case 'kiku://catalog': {
+      const catalog = {
+        artist: profileData.nameEn,
+        artistCn: profileData.nameCn,
+        activeYears: '2013–2026',
+        totalWorks: worksData.length,
+        totalSongs: discographyData.length,
+        totalAwards: awardsData.length,
+        totalMilestones: timelineData.length,
+        totalBrandEndorsements: brandsData.length,
+        featuredWorks: worksData.filter(w => w.featured).map(w => ({ title: w.titleEn, year: w.year, role: w.role })),
+        recentSingles: discographyData.filter(s => s.category === 'single').slice(0, 5).map(s => ({ title: s.titleEn, year: s.year })),
+        recentAwards: awardsData.slice(0, 5).map(a => ({ title: a.title, year: a.year, ceremony: a.ceremony })),
+        globalBrands: brandsData.filter(b => b.isGlobal).map(b => ({ brand: b.brandNameEn, year: b.year })),
+      };
+      return { contents: [{ uri, mimeType: 'application/json', text: JSON.stringify(catalog, null, 2) }] };
+    }
+
+    case 'kiku://timeline':
+      return { contents: [{ uri, mimeType: 'application/json', text: JSON.stringify(timelineData.sort((a, b) => b.year - a.year), null, 2) }] };
+
+    case 'kiku://discography':
+      return { contents: [{ uri, mimeType: 'application/json', text: JSON.stringify(discographyData, null, 2) }] };
+
+    case 'kiku://brands':
+      return { contents: [{ uri, mimeType: 'application/json', text: JSON.stringify(brandsData.sort((a, b) => b.year - a.year), null, 2) }] };
+
+    case 'kiku://social':
+      return { contents: [{ uri, mimeType: 'application/json', text: JSON.stringify(profileData.socialMedia || {}, null, 2) }] };
+
+    default:
+      throw new Error(`Unknown resource: ${uri}`);
+  }
+}

package/server/mcp/security.js

@@ -0,0 +1,138 @@
+import { timingSafeEqual } from 'node:crypto';
+
+const SECURITY_CONFIG = {
+  apiKeyRequired: !!process.env.MCP_API_KEY,
+
+  rateLimitWindowMs: 60_000,
+  rateLimitMaxRequests: 30,
+
+  maxConcurrentSessions: 100,
+  sessionTtlMs: 30 * 60_000,
+  maxMessagesPerSession: 500,
+
+  corsAllowedOrigins: (process.env.MCP_CORS_ORIGINS || '*').split(',').map(s => s.trim()),
+  maxRequestBodyBytes: 1_048_576,
+};
+
+export const MAX_REQUEST_BODY_SIZE = SECURITY_CONFIG.maxRequestBodyBytes;
+
+export function validateApiKey(req) {
+  if (!SECURITY_CONFIG.apiKeyRequired) return { valid: true };
+
+  let key = req.headers['x-api-key'];
+  if (!key) {
+    try {
+      const url = new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`);
+      key = url.searchParams.get('key') || url.searchParams.get('apiKey');
+    } catch {
+    }
+  }
+  if (!key) return { valid: false, error: 'Missing API key. Set X-API-Key header or ?key= query parameter.' };
+  const expected = Buffer.from(process.env.MCP_API_KEY || '');
+  const received = Buffer.from(String(key));
+  if (expected.length !== received.length || !timingSafeEqual(expected, received)) {
+    return { valid: false, error: 'Invalid API key.' };
+  }
+  return { valid: true };
+}
+
+const rateLimitStore = new Map();
+
+export function checkRateLimit(sessionId) {
+  const now = Date.now();
+  const entry = rateLimitStore.get(sessionId);
+
+  if (!entry || now - entry.windowStart > SECURITY_CONFIG.rateLimitWindowMs) {
+    rateLimitStore.set(sessionId, { count: 1, windowStart: now });
+    return { allowed: true, remaining: SECURITY_CONFIG.rateLimitMaxRequests - 1 };
+  }
+
+  entry.count++;
+  const remaining = SECURITY_CONFIG.rateLimitMaxRequests - entry.count;
+  if (remaining < 0) {
+    return { allowed: false, error: `Rate limit exceeded. Max ${SECURITY_CONFIG.rateLimitMaxRequests} requests per minute.` };
+  }
+  return { allowed: true, remaining };
+}
+
+const rateLimitCleanupTimer = setInterval(() => {
+  const now = Date.now();
+  for (const [id, entry] of rateLimitStore) {
+    if (now - entry.windowStart > SECURITY_CONFIG.rateLimitWindowMs * 2) {
+      rateLimitStore.delete(id);
+    }
+  }
+}, 60_000);
+rateLimitCleanupTimer.unref?.();
+
+export function sanitizeInput(input) {
+  if (typeof input === 'string') {
+    return input
+      .replace(/[<>]/g, '')
+      .replace(/\x00/g, '')
+      .slice(0, 1000);
+  }
+  if (typeof input === 'object' && input !== null) {
+    const sanitized = {};
+    for (const [key, value] of Object.entries(input)) {
+      if (typeof key === 'string' && key.length <= 100) {
+        sanitized[key] = sanitizeInput(value);
+      }
+    }
+    return sanitized;
+  }
+  return input;
+}
+
+export function validateSessionId(sessionId) {
+  if (!sessionId || typeof sessionId !== 'string') return false;
+  return /^[a-zA-Z0-9_-]{1,100}$/.test(sessionId);
+}
+
+export function setCorsHeaders(res, origin) {
+  const allowed = SECURITY_CONFIG.corsAllowedOrigins;
+  const isAllowed = allowed.includes('*') || allowed.includes(origin);
+
+  if (isAllowed) {
+    res.setHeader('Access-Control-Allow-Origin', origin || '*');
+  } else {
+    res.setHeader('Access-Control-Allow-Origin', '');
+  }
+  res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+  res.setHeader('Access-Control-Allow-Headers', 'Content-Type, X-API-Key');
+  res.setHeader('Access-Control-Max-Age', '86400');
+
+  return isAllowed;
+}
+
+export function securityMiddleware(req, res) {
+  const origin = req.headers.origin || '';
+  const corsOk = setCorsHeaders(res, origin);
+
+  if (req.method === 'OPTIONS') {
+    res.statusCode = 204;
+    res.end();
+    return { blocked: true };
+  }
+
+  if (!corsOk) {
+    res.statusCode = 403;
+    res.setHeader('Content-Type', 'application/json; charset=utf-8');
+    res.end(JSON.stringify({ error: 'Origin not allowed by CORS policy.' }));
+    return { blocked: true };
+  }
+
+  const auth = validateApiKey(req);
+  if (!auth.valid) {
+    res.statusCode = 401;
+    res.setHeader('Content-Type', 'application/json; charset=utf-8');
+    res.end(JSON.stringify({ error: auth.error }));
+    return { blocked: true };
+  }
+
+  return { blocked: false };
+}
+
+export function getSecurityConfig() {
+  return { ...SECURITY_CONFIG, apiKeyRequired: SECURITY_CONFIG.apiKeyRequired };
+}

package/server/mcp/server.js

@@ -0,0 +1,100 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import { toolDefinitions, handleToolCall } from './tools.js';
+import { resourceDefinitions, readResource } from './resources.js';
+import { getPrompt } from './prompts.js';
+
+export function createMcpServer() {
+  const server = new McpServer({
+    name: 'kiku-mcp-server',
+    version: '1.1.0',
+  }, {
+    capabilities: {
+      tools: {},
+      resources: {},
+      prompts: {},
+    },
+  });
+
+  for (const tool of toolDefinitions) {
+    server.registerTool(
+      tool.name,
+      {
+        description: tool.description,
+        inputSchema: tool.inputSchema,
+        annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: false },
+      },
+      async (args) => {
+        try {
+          const result = await handleToolCall(tool.name, args);
+          return {
+            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+            structuredContent: result,
+            isError: result?.status === 'error',
+          };
+        } catch (err) {
+          return {
+            content: [{ type: 'text', text: JSON.stringify({ status: 'error', message: err.message }) }],
+            isError: true,
+          };
+        }
+      }
+    );
+  }
+
+  const resourceMap = {
+    'kiku://bio': 'kiku-bio',
+    'kiku://awards': 'kiku-awards',
+    'kiku://catalog': 'kiku-catalog',
+    'kiku://timeline': 'kiku-timeline',
+    'kiku://discography': 'kiku-discography',
+    'kiku://brands': 'kiku-brands',
+    'kiku://social': 'kiku-social',
+  };
+
+  for (const def of resourceDefinitions) {
+    server.registerResource(
+      resourceMap[def.uri],
+      def.uri,
+      { description: def.description, mimeType: def.mimeType },
+      async (uri) => readResource(uri.href)
+    );
+  }
+
+  server.registerPrompt(
+    'recommend_series',
+    {
+      description: 'Recommend Ju Jingyi dramas based on mood or genre preference.',
+      argsSchema: {
+        mood: z.string().optional().describe('Current mood: romantic, action-packed, mysterious, emotional, or lighthearted'),
+        genre: z.string().optional().describe('Preferred genre: historical, fantasy, xianxia, romance, or suspense'),
+      },
+    },
+    async (args) => getPrompt('recommend_series', args)
+  );
+
+  server.registerPrompt(
+    'brand_portfolio',
+    { description: 'Summarize Ju Jingyi brand endorsements and commercial influence.' },
+    async (args) => getPrompt('brand_portfolio', args)
+  );
+
+  server.registerPrompt(
+    'character_summary',
+    {
+      description: 'Get a detailed summary of a specific character role by Ju Jingyi.',
+      argsSchema: {
+        character_name: z.string().min(1).describe('Character name, such as Yang Caiwei, Bai Suzhen, Lu Wuyi, or Han Yunxi'),
+      },
+    },
+    async (args) => getPrompt('character_summary', args)
+  );
+
+  server.registerPrompt(
+    'career_overview',
+    { description: 'Get a comprehensive career overview organized by era.' },
+    async (args) => getPrompt('career_overview', args)
+  );
+
+  return server;
+}

package/server/mcp/stdio.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { createMcpServer } from './server.js';
+
+const server = createMcpServer();
+const transport = new StdioServerTransport(process.stdin, process.stdout, { maxBufferSize: 2 * 1024 * 1024 });
+
+let closing = false;
+async function shutdown(exitCode = 0) {
+  if (closing) return;
+  closing = true;
+  await Promise.allSettled([transport.close(), server.close()]);
+  process.exitCode = exitCode;
+}
+
+process.once('SIGINT', () => { void shutdown(130); });
+process.once('SIGTERM', () => { void shutdown(143); });
+process.once('uncaughtException', error => {
+  process.stderr.write(`Kiku MCP fatal error: ${error.message}\n`);
+  void shutdown(1);
+});
+process.once('unhandledRejection', error => {
+  process.stderr.write(`Kiku MCP unhandled rejection: ${error?.message || String(error)}\n`);
+  void shutdown(1);
+});
+
+try {
+  await server.connect(transport);
+} catch (error) {
+  process.stderr.write(`Unable to start Kiku MCP server: ${error.message}\n`);
+  await shutdown(1);
+}