kiku-agent 1.2.0 → 1.3.1

package/server/mcp/security.js

@@ -1,7 +1,7 @@
 import { timingSafeEqual } from 'node:crypto';
 
 const SECURITY_CONFIG = {
-  apiKeyRequired: !!process.env.MCP_API_KEY,
+  apiKeyRequired: Boolean(process.env.MCP_API_KEY || process.env.NODE_ENV === 'production'),
 
   rateLimitWindowMs: 60_000,
   rateLimitMaxRequests: 30,
@@ -10,7 +10,7 @@ const SECURITY_CONFIG = {
   sessionTtlMs: 30 * 60_000,
   maxMessagesPerSession: 500,
 
-  corsAllowedOrigins: (process.env.MCP_CORS_ORIGINS || '').split(',').map(s => s.trim()).filter(Boolean),
+  corsAllowedOrigins: (process.env.MCP_CORS_ORIGINS || 'https://jujingyi-kikuuu.vercel.app').split(',').map(s => s.trim()).filter(Boolean),
   maxRequestBodyBytes: 1_048_576,
 };
 
@@ -19,13 +19,16 @@ 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'];
+  let key = req?.headers?.['x-api-key'];
   if (!key) {
-    const authHeader = req.headers['authorization'];
+    const authHeader = req?.headers?.['authorization'];
     if (authHeader && typeof authHeader === 'string' && authHeader.startsWith('Bearer ')) {
       key = authHeader.slice(7).trim();
     }
   }
+  if (!process.env.MCP_API_KEY) {
+    return { valid: false, error: 'MCP API key is not configured on the server. Please set MCP_API_KEY.' };
+  }
   if (!key) return { valid: false, error: 'Missing API key. Set X-API-Key header or Authorization: Bearer <key>.' };
   const expected = Buffer.from(process.env.MCP_API_KEY || '');
   const received = Buffer.from(String(key));
@@ -88,16 +91,24 @@ export function validateSessionId(sessionId) {
   return /^[a-zA-Z0-9_-]{1,100}$/.test(sessionId);
 }
 
-export function setCorsHeaders(res, origin) {
-  const allowed = SECURITY_CONFIG.corsAllowedOrigins;
-  const isLocalhost = process.env.NODE_ENV !== 'production' &&
-    (origin.startsWith('http://localhost:') || origin.startsWith('http://127.0.0.1:') || origin === 'http://localhost' || origin === 'http://127.0.0.1');
-  const isAllowed = !origin || allowed.includes(origin) || isLocalhost;
-
-  if (origin && isAllowed) {
-    res.setHeader('Access-Control-Allow-Origin', origin);
-    res.setHeader('Vary', 'Origin');
-  }
+export function setCorsHeaders(res, origin) {
+  const allowed = SECURITY_CONFIG.corsAllowedOrigins;
+  let isLocalhost = false;
+  if (process.env.NODE_ENV !== 'production' && origin) {
+    try {
+      const parsed = new URL(origin);
+      isLocalhost = (parsed.hostname === 'localhost' || parsed.hostname === '127.0.0.1') &&
+        (parsed.protocol === 'http:' || parsed.protocol === 'https:');
+    } catch {
+      isLocalhost = false;
+    }
+  }
+  const isAllowed = !origin || allowed.includes(origin) || isLocalhost;
+
+  if (origin && isAllowed) {
+    res.setHeader('Access-Control-Allow-Origin', origin);
+    res.setHeader('Vary', 'Origin');
+  }
   res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
   res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization, X-Requested-With, X-API-Key, Accept');
   res.setHeader('Access-Control-Max-Age', '86400');

package/server/mcp/server.js

@@ -5,6 +5,27 @@ import { toolDefinitions, handleToolCall } from './tools.js';
 import { resourceDefinitions, readResource } from './resources.js';
 import { getPrompt } from './prompts.js';
 
+const WRITE_TOOLS = new Set([
+  'manage_skill',
+  'play_music', 'stop_music', 'pause_music', 'resume_music',
+  'mute_music', 'unmute_music', 'next_track', 'prev_track',
+  'add_to_queue', 'remove_from_queue', 'clear_queue',
+]);
+
+  
+const NON_IDEMPOTENT_TOOLS = new Set([
+  'manage_skill', 'play_music', 'add_to_queue', 'remove_from_queue',
+  'clear_queue', 'next_track', 'prev_track', 'run_quiz',
+]);
+
+const OPEN_WORLD_TOOLS = new Set([
+  'web_search', 'web_extract', 'fetch_webpage', 'fetch_api', 'fetch_json',
+  'screenshot_webpage', 'search_news', 'fetch_rss', 'search_encyclopedia',
+  'search_music_platforms', 'search_chinese_web', 'search_bilibili',
+  'search_youtube', 'search_web_images', 'run_quiz', 'run_subagent',
+  'run_deep_research', 'verify_claim', 'suggest_topics',
+]);
+
 export function createMcpServer(options = {}) {
   const toolOptions = {
     transport: options.transport || 'stdio',
@@ -52,12 +73,19 @@ export function createMcpServer(options = {}) {
   });
 
   for (const tool of toolDefinitions) {
+    const description = tool.name === 'get_api_key'
+      ? `${tool.description} (SENSITIVE: returns a stored Developer VIP API key — do not expose it publicly.)`
+      : tool.description;
     server.registerTool(
       tool.name,
       {
-        description: tool.description,
+        description,
         inputSchema: tool.inputSchema,
-        annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: false },
+        annotations: {
+          readOnlyHint: !WRITE_TOOLS.has(tool.name),
+          idempotentHint: !NON_IDEMPOTENT_TOOLS.has(tool.name),
+          openWorldHint: OPEN_WORLD_TOOLS.has(tool.name),
+        },
       },
       async (args) => {
         try {
@@ -85,11 +113,13 @@ export function createMcpServer(options = {}) {
     'kiku://discography': 'kiku-discography',
     'kiku://brands': 'kiku-brands',
     'kiku://social': 'kiku-social',
+    'kiku://industry-index': 'kiku-industry-index',
   };
 
   for (const def of resourceDefinitions) {
+    const resourceName = resourceMap[def.uri] || def.uri.replace('kiku://', 'kiku-');
     server.registerResource(
-      resourceMap[def.uri],
+      resourceName,
       def.uri,
       { description: def.description, mimeType: def.mimeType },
       async (uri) => readResource(uri.href)
@@ -131,5 +161,64 @@ export function createMcpServer(options = {}) {
     async (args) => getPrompt('career_overview', args)
   );
 
+  server.registerPrompt(
+    'draft_fan_fiction',
+    {
+      description: 'Draft creative fan fiction scenarios incorporating authentic Ju Jingyi characters and lore.',
+      argsSchema: {
+        character: z.string().min(1).describe('Character name (e.g. "Yang Caiwei", "Han Yunxi", "Fu Rong")'),
+        theme: z.string().optional().describe('Story theme or mood (mystery, romance, fantasy adventure)'),
+        setting: z.string().optional().describe('Story backdrop or scenario'),
+      },
+    },
+    async (args) => getPrompt('draft_fan_fiction', args)
+  );
+
+  server.registerPrompt(
+    'analyze_drama_rating',
+    {
+      description: 'Provide an analytical overview of a drama\'s reception, milestones, and iconic performances.',
+      argsSchema: {
+        title: z.string().min(1).describe('Drama title (e.g. "In Blossom", "Legend of Yunxi")'),
+      },
+    },
+    async (args) => getPrompt('analyze_drama_rating', args)
+  );
+
+  server.registerPrompt(
+    'compare_discography_era',
+    {
+      description: 'Compare musical styles and evolution across Ju Jingyi\'s idol, solo, and studio eras.',
+      argsSchema: {
+        era_a: z.string().optional().describe('First era (e.g. "snh48", "solo_early", "studio_era")'),
+        era_b: z.string().optional().describe('Second era (e.g. "modern", "solo")'),
+      },
+    },
+    async (args) => getPrompt('compare_discography_era', args)
+  );
+
+  server.registerPrompt(
+    'investigate_viral_claim',
+    {
+      description: 'Investigate a viral claim, set leak, casting rumor, or news report about Ju Jingyi using multi-tool evidence and catalog cross-referencing.',
+      argsSchema: {
+        claim: z.string().min(1).describe('The viral rumor, set leak, or statement to investigate'),
+        platform_hint: z.string().optional().describe('Platform where the claim went viral (e.g. "weibo", "douyin", "baidu")'),
+      },
+    },
+    async (args) => getPrompt('investigate_viral_claim', args)
+  );
+
+  server.registerPrompt(
+    'deep_research_topic',
+    {
+      description: 'Perform an exhaustive deep research investigation on any Ju Jingyi entertainment topic across catalog, live Chinese media, news, and images.',
+      argsSchema: {
+        topic: z.string().min(1).describe('The topic, milestone, or controversy to research in depth'),
+      },
+    },
+    async (args) => getPrompt('deep_research_topic', args)
+  );
+
   return server;
 }

package/server/mcp/tools.js

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { executeTool, toolsSchema } from '../agent/tools.js';
+import { sanitizeInput } from './security.js';
 
-// Rich catalog/database tools — safe to expose over public MCP.
 const PUBLIC_TOOL_NAMES = new Set([
   'get_profile_and_fandom',
   'get_quotes',
@@ -18,26 +18,34 @@ const PUBLIC_TOOL_NAMES = new Set([
   'get_gallery_photos',
   'global_search',
   'get_system_stats',
+  'get_current_datetime',
+  'get_youtube_transcript',
+  'search_news',
+  'fetch_rss',
+  'search_encyclopedia',
+  'search_music_platforms',
+  'get_entertainment_metrics',
+  'get_industry_index',
 ]);
 
-// Web tools — gated behind KIKU_MCP_ENABLE_WEB_TOOLS flag.
-const OPTIONAL_WEB_TOOL_NAMES = new Set(['web_search', 'fetch_webpage', 'fetch_api', 'web_extract']);
+const OPTIONAL_WEB_TOOL_NAMES = new Set(['web_search', 'fetch_webpage', 'fetch_api', 'web_extract', 'search_web_images']);
 const webToolsEnabled = process.env.KIKU_MCP_ENABLE_WEB_TOOLS === 'true';
 
-// Anonymous callers may search public music metadata, but cannot mutate playback state.
+const OPTIONAL_CN_TOOL_NAMES = new Set(['search_chinese_web', 'search_bilibili', 'search_web_images']);
+const cnToolsEnabled = process.env.KIKU_ENABLE_CN_WEB_TOOLS === 'true';
+
 const MUSIC_TOOL_NAMES = new Set([
   'search_youtube',
 ]);
 
-// Stateless engagement tools are safe to expose.
 const RESEARCH_TOOL_NAMES = new Set([
   'suggest_topics',
   'run_quiz',
+  'checkpoint_step',
+  'record_failure',
+  'load_active_run',
 ]);
 
-// Privileged tools — they touch the filesystem, server-local resources, secrets, or
-// mutated server state. Exposed over MCP but REQUIRE authorization (a valid MCP_API_KEY
-// / X-API-Key / Bearer header). Never callable anonymously on the public HTTP endpoint.
 const PRIVILEGED_TOOL_NAMES = new Set([
   'read_local_file',
   'list_directory',
@@ -64,12 +72,13 @@ const PRIVILEGED_TOOL_NAMES = new Set([
   'fetch_json',
 ]);
 
-// Any tool that is not privileged is public.
 const isPrivileged = (name) => PRIVILEGED_TOOL_NAMES.has(name);
 
 function isAllowedTool(name) {
   if (PUBLIC_TOOL_NAMES.has(name) || MUSIC_TOOL_NAMES.has(name) || RESEARCH_TOOL_NAMES.has(name)) return true;
-  if (OPTIONAL_WEB_TOOL_NAMES.has(name)) return webToolsEnabled;
+  if (OPTIONAL_WEB_TOOL_NAMES.has(name) && webToolsEnabled) return true;
+  if (OPTIONAL_CN_TOOL_NAMES.has(name) && cnToolsEnabled) return true;
+  if (OPTIONAL_WEB_TOOL_NAMES.has(name) || OPTIONAL_CN_TOOL_NAMES.has(name)) return false;
   return PRIVILEGED_TOOL_NAMES.has(name);
 }
 
@@ -164,7 +173,7 @@ export async function handleToolCall(toolName, args = {}, options = {}) {
     }
   }
 
-  const adaptedArgs = { ...(args || {}) };
+  const adaptedArgs = { ...sanitizeInput(args || {}) };
   if (toolName === 'search_gallery') delete adaptedArgs.query;
   if (adaptedArgs.category && definition.targetName === 'search_discography' && !adaptedArgs.type) {
     adaptedArgs.type = adaptedArgs.category;

package/server/routes/agent.js

@@ -0,0 +1,55 @@
+import { KikuAgent } from '../agent/agentCore.js';
+import { AgentMemory } from '../agent/memory.js';
+import { PUBLIC_REMOTE_TOOL_NAMES } from '../agent/publicTools.js';
+
+export function getSharedAgent(options = {}) {
+  return new KikuAgent({
+    provider: 'lmstudio',
+    apiKey: '',
+    ...options,
+    memory: new AgentMemory({ persistence: false }),
+    sessionPersistence: false,
+    allowedToolNames: PUBLIC_REMOTE_TOOL_NAMES,
+  });
+}
+
+export async function handleAgentChatStream(req, res, queryPrompt, agentOptions = {}) {
+  res.statusCode = 200;
+  res.setHeader('Content-Type', 'text/event-stream; charset=utf-8');
+  res.setHeader('Cache-Control', 'no-cache, no-transform');
+  res.setHeader('Connection', 'keep-alive');
+  res.setHeader('X-Accel-Buffering', 'no');
+  res.setHeader('X-Content-Type-Options', 'nosniff');
+  res.setHeader('X-Frame-Options', 'DENY');
+  res.setHeader('Referrer-Policy', 'strict-origin-when-cross-origin');
+
+  const sendEvent = (event, data) => {
+    res.write(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
+  };
+
+  const agent = getSharedAgent(agentOptions);
+  await agent.ready();
+
+  try {
+    sendEvent('start', { prompt: queryPrompt, timestamp: Date.now() });
+
+    await agent.ask(queryPrompt, {
+      onReasoningStart: () => sendEvent('thought_start', {}),
+      onReasoningDelta: (chunk) => sendEvent('thought_delta', { chunk }),
+      onReasoningEnd: () => sendEvent('thought_end', {}),
+      onToolStart: (name, args) => sendEvent('tool_start', { name, args }),
+      onToolResult: (name, result, durationMs) => sendEvent('tool_result', { name, result, durationMs }),
+      onTokenDelta: (chunk) => sendEvent('token', { chunk }),
+      onFinalAnswer: (answer, meta) => sendEvent('done', { answer, meta }),
+      onError: (err) => {
+        console.error('Agent stream error:', err);
+        sendEvent('error', { error: process.env.NODE_ENV === 'development' ? err.message : 'Agent stream execution encountered an issue.' });
+      }
+    });
+  } catch (error) {
+    console.error('Agent chat stream error:', error);
+    sendEvent('error', { error: process.env.NODE_ENV === 'development' ? error.message : 'Agent stream execution failed.' });
+  } finally {
+    res.end();
+  }
+}