kiku-agent 1.3.3 → 1.3.5

package/README.md

@@ -52,7 +52,7 @@ kiku-agent
 ```
 
 > [!NOTE]
-> The global package deliberately excludes native binary build dependencies (Python, `node-gyp`, Visual Studio C++ build tools are not required). For a local checkout before publishing, pack and install via `npm install -g ./kiku-agent-1.3.3.tgz`.
+> The global package deliberately excludes native binary build dependencies (Python, `node-gyp`, Visual Studio C++ build tools are not required). For a local checkout before publishing, pack and install via `npm install -g ./kiku-agent-1.3.5.tgz`.
 
 ### Zero-Install One-Shot Query
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kiku-agent",
-  "version": "1.3.3",
+  "version": "1.3.5",
   "description": "Kiku AI terminal agent and MCP server for Ju Jingyi knowledge, media, and career data.",
   "license": "GPL-3.0",
   "type": "module",
@@ -59,6 +59,7 @@
     "kiku-agent": "node server/agent/cli.js",
     "web-chat": "node server/web-chat/server.js --port 3002 --open",
     "kiku-mcp": "node server/mcp/stdio.js",
+    "mcp:sse": "node server/mcp/sseServer.js",
     "kiku-ink": "npx tsx server/agent/ink/main.jsx",
     "vram:live": "node server/agent/cli.js --vram",
     "profile:nsys": "node scripts/profileNsys.js",

package/server/apiRouter.js

@@ -5500,6 +5500,12 @@ function getComprehensiveGalleryList() {
 
   if (pathname === '/mcp') {
     if (req.method === 'GET') {
+      const accept = req.headers.accept || '';
+      if (accept.includes('text/event-stream') || req.url.includes('format=sse')) {
+        const { handleMcpSse } = await import('./mcp/handler.js');
+        return await handleMcpSse(req, res);
+      }
+
       const { getMcpSessionStats } = await import('./mcp/handler.js');
       const { toolDefinitions } = await import('./mcp/tools.js');
       const { resourceDefinitions } = await import('./mcp/resources.js');
@@ -5539,6 +5545,11 @@ function getComprehensiveGalleryList() {
     }
   }
 
+  if (pathname === '/mcp/messages' && req.method === 'POST') {
+    const { handleMcpMessage } = await import('./mcp/handler.js');
+    return await handleMcpMessage(req, res);
+  }
+
   if (pathname === '/mcp/sse' || pathname === '/mcp/message') {
     return sendJson(res, 410, {
       status: 'error',

package/server/mcp/handler.js

@@ -19,12 +19,52 @@ function validateRequestSize(req, res) {
   return true;
 }
 
+import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
+
+const sseSessions = new Map();
+
 export async function handleMcpSse(req, res) {
-  sendJson(res, 410, { error: 'Legacy SSE transport removed. Use POST /mcp.' });
+  const security = await securityMiddleware(req, res);
+  if (security.blocked) return;
+
+  const auth = security.auth || await validateApiKey(req);
+  const rateBucket = auth.keyPrefix ? `mcp-key:${auth.keyPrefix}` : `mcp-sse:${req.socket?.remoteAddress || 'unknown'}`;
+  const maxLimit = auth.rateLimit || 30;
+  const rate = checkRateLimit(rateBucket, maxLimit);
+  if (!rate.allowed) return sendJson(res, 429, { error: rate.error }, { 'Retry-After': '60' });
+
+  const authorized = auth.valid && auth.authorized !== false;
+  const server = createMcpServer({ transport: 'sse', authorized, tier: auth.tier });
+  const transport = new SSEServerTransport('/mcp/messages', res);
+  sseSessions.set(transport.sessionId, { transport, server });
+
+  res.on('close', () => {
+    sseSessions.delete(transport.sessionId);
+    server.close().catch(() => {});
+  });
+
+  try {
+    await server.connect(transport);
+  } catch (err) {
+    console.error(`MCP SSE error: ${err.message}`);
+    sseSessions.delete(transport.sessionId);
+  }
 }
 
 export async function handleMcpMessage(req, res) {
-  sendJson(res, 410, { error: 'Legacy SSE transport removed. Use POST /mcp.' });
+  const url = new URL(req.url, 'http://localhost');
+  const sessionId = url.searchParams.get('sessionId');
+  const session = sessionId ? sseSessions.get(sessionId) : null;
+  if (!session) {
+    return sendJson(res, 404, { error: 'SSE session not found or expired. Re-connect to /mcp.' });
+  }
+
+  try {
+    await session.transport.handlePostMessage(req, res);
+  } catch (err) {
+    console.error(`MCP SSE message error: ${err.message}`);
+    if (!res.headersSent) sendJson(res, 500, { error: err.message });
+  }
 }
 
 export async function handleMcpHttp(req, res) {

package/server/mcp/sseServer.js

@@ -0,0 +1,146 @@
+#!/usr/bin/env node
+
+/**
+ * Ju Jingyi MCP Remote SSE Server (OpenCode & Open WebUI Compatible)
+ * 
+ * Provides an SSE (Server-Sent Events) Model Context Protocol endpoint
+ * supporting remote AI clients like OpenCode, Open WebUI, and legacy MCP consumers.
+ */
+
+import http from 'node:http';
+import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
+import { createMcpServer } from './server.js';
+import { PACKAGE_VERSION } from '../agent/version.js';
+
+const PORT = Number.parseInt(process.env.KIKU_MCP_PORT || process.env.PORT || '3005', 10);
+const HOST = process.env.KIKU_MCP_HOST || '127.0.0.1';
+
+const sessions = new Map();
+
+function sendJson(res, statusCode, data, extraHeaders = {}) {
+  if (res.headersSent) return;
+  res.statusCode = statusCode;
+  res.setHeader('Content-Type', 'application/json; charset=utf-8');
+  for (const [k, v] of Object.entries(extraHeaders)) {
+    res.setHeader(k, v);
+  }
+  res.end(JSON.stringify(data, null, 2));
+}
+
+export function createMcpSseHttpServer(options = {}) {
+  const server = http.createServer(async (req, res) => {
+    
+    res.setHeader('Access-Control-Allow-Origin', '*');
+    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+    res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization, X-API-Key, Accept');
+
+    if (req.method === 'OPTIONS') {
+      res.statusCode = 204;
+      return res.end();
+    }
+
+    const host = req.headers.host || `${HOST}:${PORT}`;
+    const url = new URL(req.url, `http://${host}`);
+    const pathname = url.pathname.replace(/\/+$/, '') || '/';
+
+    
+    if (pathname === '/mcp') {
+      if (req.method === 'GET') {
+        const accept = req.headers.accept || '';
+        const wantsSse = accept.includes('text/event-stream') || url.searchParams.get('format') === 'sse';
+
+       
+        const rawAuth = req.headers['x-api-key']
+          || (req.headers.authorization ? req.headers.authorization.replace(/^Bearer\s+/i, '') : '')
+          || url.searchParams.get('apiKey')
+          || '';
+        const apiKey = String(rawAuth).trim();
+        const authorized = Boolean(apiKey.startsWith('kiku_') || apiKey.length >= 16);
+
+        if (wantsSse) {
+          const mcpServer = createMcpServer({
+            transport: 'sse',
+            authorized,
+            tier: apiKey ? 'mcp_vip' : 'standard',
+          });
+
+          
+          const transport = new SSEServerTransport('/mcp/messages', res);
+          sessions.set(transport.sessionId, { transport, mcpServer, createdAt: Date.now() });
+
+          res.on('close', () => {
+            sessions.delete(transport.sessionId);
+            mcpServer.close().catch(() => {});
+          });
+
+          try {
+            await mcpServer.connect(transport);
+          } catch (err) {
+            console.error('[MCP SSE Server] Connect error:', err.message);
+            sessions.delete(transport.sessionId);
+          }
+          return;
+        }
+
+        
+        return sendJson(res, 200, {
+          status: 'success',
+          code: 200,
+          name: 'kiku',
+          title: 'kiku',
+          version: PACKAGE_VERSION,
+          protocol: 'mcp',
+          transport: 'sse',
+          endpoints: {
+            sse: `http://${host}/mcp`,
+            messages: `http://${host}/mcp/messages`
+          },
+          message: 'Ju Jingyi MCP SSE Server is active. Connect with OpenCode remote configuration.',
+          authReceived: Boolean(apiKey)
+        });
+      }
+    }
+
+    
+    if ((pathname === '/mcp/messages' || pathname === '/mcp') && req.method === 'POST') {
+      const sessionId = url.searchParams.get('sessionId');
+      const session = sessionId ? sessions.get(sessionId) : null;
+
+      if (!session) {
+        return sendJson(res, 404, {
+          status: 'error',
+          code: 404,
+          error: 'SSE session not found or expired. Please re-connect to /mcp.'
+        });
+      }
+
+      try {
+        await session.transport.handlePostMessage(req, res);
+      } catch (err) {
+        console.error('[MCP SSE Server] Message error:', err.message);
+        if (!res.headersSent) {
+          sendJson(res, 500, { error: err.message });
+        }
+      }
+      return;
+    }
+
+   
+    sendJson(res, 404, {
+      status: 'error',
+      code: 404,
+      error: `Endpoint ${pathname} not found on MCP SSE Server.`
+    });
+  });
+
+  return server;
+}
+
+if (process.argv[1] && import.meta.url === `file:///${process.argv[1].replace(/\\/g, '/')}`) {
+  const server = createMcpSseHttpServer();
+  server.listen(PORT, HOST, () => {
+    console.log(`\n🌸 Ju Jingyi MCP Remote SSE Server v${PACKAGE_VERSION}`);
+    console.log(`📡 URL:      http://${HOST}:${PORT}/mcp`);
+    console.log(`⚡ Ready for OpenCode remote connections on port ${PORT}\n`);
+  });
+}

package/server/mcp/tests/connection.test.js

@@ -160,3 +160,44 @@ test('Legacy MCP SSE and message routes respond with HTTP 410 Gone', async () =>
     await new Promise(resolve => httpServer.close(resolve));
   }
 });
+
+test('MCP client connects over SSE at /mcp with Accept: text/event-stream (OpenCode compatibility)', { timeout: 30_000 }, async () => {
+  const previousApiKey = process.env.MCP_API_KEY;
+  process.env.MCP_API_KEY = 'kiku_mcp_sk_0552855023fb5cb09707020b65000bd9';
+  const { SSEClientTransport } = await import('@modelcontextprotocol/sdk/client/sse.js');
+  const { handleApiRequest } = await import('../../apiRouter.js');
+  const httpServer = createServer((req, res) => {
+    void handleApiRequest(req, res).catch(error => {
+      res.statusCode = 500;
+      res.end(error.message);
+    });
+  });
+  await new Promise((resolve, reject) => {
+    httpServer.once('error', reject);
+    httpServer.listen(0, '127.0.0.1', resolve);
+  });
+
+  const address = httpServer.address();
+  const baseUrl = `http://127.0.0.1:${address.port}`;
+
+  const transport = new SSEClientTransport(new URL(`${baseUrl}/mcp`), {
+    requestInit: { headers: { 'X-API-Key': 'kiku_mcp_sk_0552855023fb5cb09707020b65000bd9' } },
+  });
+  const client = new Client({ name: 'opencode-compat-test', version: PACKAGE_VERSION }, { capabilities: {} });
+
+  try {
+    await client.connect(transport);
+    const tools = await client.listTools();
+    assert.ok(tools.tools.length >= 15);
+    assert.ok(tools.tools.some(t => t.name === 'search_works'));
+    const call = await client.callTool({ name: 'search_works', arguments: { query: 'In Blossom' } });
+    assert.equal(call.isError, false);
+    const payload = JSON.parse(call.content[0].text);
+    assert.equal(payload.status, 'success');
+  } finally {
+    await client.close().catch(() => {});
+    await new Promise(resolve => httpServer.close(resolve));
+    if (previousApiKey === undefined) delete process.env.MCP_API_KEY;
+    else process.env.MCP_API_KEY = previousApiKey;
+  }
+});