kiku-agent 1.3.1 → 1.3.3

package/server/web-chat/routes/mcpRoute.js

@@ -0,0 +1,386 @@
+import { toolsSchema } from '../../agent/tools.js';
+import { toolDefinitions as mcpToolDefinitions } from '../../mcp/tools.js';
+import { TOOL_CLUSTERS } from '../../agent/toolRouter.js';
+import { currentAgent } from '../core/connection.js';
+import { PACKAGE_VERSION } from '../../agent/version.js';
+import { getMcpSessionStats } from '../../mcp/handler.js';
+import { sendJson } from '../core/errorHandler.js';
+
+export function buildMcpClientConfigs(baseUrl) {
+  const httpUrl = `${baseUrl}/mcp`;
+  const stdioCmd = 'npx';
+  const stdioArgs = ['-y', '-p', 'kiku-agent', 'kiku-mcp'];
+  const stdioEnv = { KIKU_MCP_ENABLE_WEB_TOOLS: 'true' };
+
+  return {
+    claudeDesktop: {
+      id: 'claudeDesktop',
+      name: 'Claude Desktop',
+      file: 'claude_desktop_config.json',
+      pathHint: 'macOS: ~/Library/Application Support/Claude/ • Win: %APPDATA%\\Claude\\',
+      desc: 'Anthropic Claude Desktop App (macOS & Windows)',
+      icon: 'bi-robot',
+      category: 'Desktop App',
+      http: {
+        mcpServers: {
+          kiku: { url: httpUrl }
+        }
+      },
+      stdio: {
+        mcpServers: {
+          kiku: {
+            command: stdioCmd,
+            args: stdioArgs,
+            env: stdioEnv
+          }
+        }
+      },
+      mcpServers: {
+        kiku: { url: httpUrl }
+      }
+    },
+    cursor: {
+      id: 'cursor',
+      name: 'Cursor',
+      file: '.cursor/mcp.json',
+      pathHint: '.cursor/mcp.json (ในโฟลเดอร์โปรเจกต์ หรือ ~/.cursor/mcp.json)',
+      desc: 'Cursor AI Code Editor',
+      icon: 'bi-cursor',
+      category: 'IDE',
+      http: {
+        mcpServers: {
+          kiku: { url: httpUrl }
+        }
+      },
+      stdio: {
+        mcpServers: {
+          kiku: {
+            command: stdioCmd,
+            args: stdioArgs,
+            env: stdioEnv
+          }
+        }
+      },
+      mcpServers: {
+        kiku: { url: httpUrl }
+      }
+    },
+    windsurf: {
+      id: 'windsurf',
+      name: 'Windsurf',
+      file: '~/.codeium/windsurf/mcp_config.json',
+      pathHint: '~/.codeium/windsurf/mcp_config.json',
+      desc: 'Codeium Windsurf Next-Gen IDE',
+      icon: 'bi-wind',
+      category: 'IDE',
+      http: {
+        mcpServers: {
+          kiku: { serverUrl: httpUrl }
+        }
+      },
+      stdio: {
+        mcpServers: {
+          kiku: {
+            command: stdioCmd,
+            args: stdioArgs,
+            env: stdioEnv
+          }
+        }
+      },
+      mcpServers: {
+        kiku: { serverUrl: httpUrl }
+      }
+    },
+    vscode: {
+      id: 'vscode',
+      name: 'VS Code & Copilot',
+      file: '.vscode/mcp.json',
+      pathHint: '.vscode/mcp.json (ในโปรเจกต์ หรือ User MCP Settings)',
+      desc: 'Visual Studio Code & GitHub Copilot Agent',
+      icon: 'bi-code-square',
+      category: 'IDE',
+      http: {
+        servers: {
+          kiku: {
+            type: 'http',
+            url: httpUrl
+          }
+        }
+      },
+      stdio: {
+        servers: {
+          kiku: {
+            type: 'stdio',
+            command: stdioCmd,
+            args: stdioArgs,
+            env: stdioEnv
+          }
+        }
+      },
+      servers: {
+        kiku: {
+          type: 'http',
+          url: httpUrl
+        }
+      }
+    },
+    antigravity: {
+      id: 'antigravity',
+      name: 'Google Antigravity (AGY)',
+      file: '.agents/mcp_config.json',
+      pathHint: '.agents/mcp_config.json หรือ ~/.gemini/config/mcp_config.json',
+      desc: 'Google Antigravity IDE & AGY Subagent Framework',
+      icon: 'bi-stars',
+      category: 'IDE / Agent',
+      http: {
+        mcpServers: {
+          kiku: { url: httpUrl }
+        }
+      },
+      stdio: {
+        mcpServers: {
+          kiku: {
+            command: stdioCmd,
+            args: stdioArgs,
+            env: stdioEnv
+          }
+        }
+      },
+      mcpServers: {
+        kiku: { url: httpUrl }
+      }
+    },
+    cline: {
+      id: 'cline',
+      name: 'Cline / Roo Code',
+      file: 'cline_mcp_settings.json',
+      pathHint: 'ส่วนขยาย Cline / Roo Code Settings',
+      desc: 'Cline & Roo Code Autonomous Agent Extension',
+      icon: 'bi-cpu',
+      category: 'Extension Agent',
+      http: {
+        mcpServers: {
+          kiku: {
+            url: httpUrl,
+            disabled: false,
+            alwaysAllow: []
+          }
+        }
+      },
+      stdio: {
+        mcpServers: {
+          kiku: {
+            command: stdioCmd,
+            args: stdioArgs,
+            env: stdioEnv,
+            disabled: false,
+            alwaysAllow: []
+          }
+        }
+      },
+      mcpServers: {
+        kiku: {
+          url: httpUrl,
+          disabled: false,
+          alwaysAllow: []
+        }
+      }
+    },
+    claudeCode: {
+      id: 'claudeCode',
+      name: 'Claude Code CLI',
+      file: '~/.claude/mcp.json',
+      pathHint: 'Terminal CLI: claude mcp add kiku ' + httpUrl,
+      desc: 'Anthropic Claude Code Terminal Agent',
+      icon: 'bi-terminal',
+      category: 'CLI Agent',
+      cliCommand: `claude mcp add kiku ${httpUrl}`,
+      http: {
+        mcpServers: {
+          kiku: {
+            type: 'http',
+            url: httpUrl
+          }
+        }
+      },
+      stdio: {
+        mcpServers: {
+          kiku: {
+            type: 'stdio',
+            command: stdioCmd,
+            args: stdioArgs,
+            env: stdioEnv
+          }
+        }
+      },
+      mcpServers: {
+        kiku: {
+          type: 'http',
+          url: httpUrl
+        }
+      }
+    },
+    geminiCli: {
+      id: 'geminiCli',
+      name: 'Gemini CLI',
+      file: '~/.gemini/mcp.json',
+      pathHint: '~/.gemini/mcp.json หรือ gemini.json',
+      desc: 'Google Gemini CLI & Developer Tools',
+      icon: 'bi-gem',
+      category: 'CLI Agent',
+      http: {
+        mcpServers: {
+          kiku: {
+            httpUrl: httpUrl
+          }
+        }
+      },
+      stdio: {
+        mcpServers: {
+          kiku: {
+            command: stdioCmd,
+            args: stdioArgs,
+            env: stdioEnv
+          }
+        }
+      },
+      mcpServers: {
+        kiku: {
+          httpUrl: httpUrl
+        }
+      }
+    },
+    librechat: {
+      id: 'librechat',
+      name: 'LibreChat',
+      file: 'librechat.yaml',
+      pathHint: 'librechat.yaml (YAML Format)',
+      desc: 'LibreChat Multi-User AI Web Interface',
+      icon: 'bi-chat-square-text',
+      category: 'Web UI',
+      format: 'yaml',
+      http: `mcpServers:\n  kiku:\n    type: streamable-http\n    url: ${httpUrl}`,
+      stdio: `mcpServers:\n  kiku:\n    type: stdio\n    command: npx\n    args:\n      - -y\n      - -p\n      - kiku-agent\n      - kiku-mcp\n    env:\n      KIKU_MCP_ENABLE_WEB_TOOLS: "true"`,
+      httpYaml: `mcpServers:\n  kiku:\n    type: streamable-http\n    url: ${httpUrl}`,
+      stdioYaml: `mcpServers:\n  kiku:\n    type: stdio\n    command: npx\n    args:\n      - -y\n      - -p\n      - kiku-agent\n      - kiku-mcp\n    env:\n      KIKU_MCP_ENABLE_WEB_TOOLS: "true"`,
+      raw: `mcpServers:\n  kiku:\n    type: streamable-http\n    url: ${httpUrl}`
+    },
+    opencode: {
+      id: 'opencode',
+      name: 'OpenCode / Open WebUI',
+      file: 'opencode.json',
+      pathHint: 'opencode.json (OpenCode / Open WebUI)',
+      desc: 'OpenCode & Open WebUI AI Agent Framework',
+      icon: 'bi-globe',
+      category: 'Web UI / Agent',
+      http: {
+        $schema: 'https://opencode.ai/config.json',
+        mcp: {
+          kiku: {
+            type: 'remote',
+            url: httpUrl,
+            enabled: true
+          }
+        }
+      },
+      stdio: {
+        $schema: 'https://opencode.ai/config.json',
+        mcp: {
+          kiku: {
+            type: 'local',
+            command: ['npx', '-y', '-p', 'kiku-agent', 'kiku-mcp'],
+            environment: stdioEnv,
+            enabled: true
+          }
+        }
+      },
+      $schema: 'https://opencode.ai/config.json',
+      mcp: {
+        kiku: {
+          type: 'remote',
+          url: httpUrl,
+          enabled: true
+        }
+      }
+    }
+  };
+}
+
+export async function handleMcpStatusRoute(req, res, options = {}) {
+  const port = Number(options.port || 3002);
+  const host = req.headers.host || `localhost:${port}`;
+  const protocol = req.headers['x-forwarded-proto'] || 'http';
+  const baseUrl = `${protocol}://${host}`;
+
+  const mcpToolSet = new Set(mcpToolDefinitions.map(t => t.name));
+
+  const toolClusterMap = new Map();
+  for (const [cluster, tools] of Object.entries(TOOL_CLUSTERS)) {
+    for (const t of tools) {
+      toolClusterMap.set(t, cluster);
+    }
+  }
+
+  const agentTools = currentAgent?.getAllToolsSchema?.() || toolsSchema;
+  const tools = agentTools.map(t => {
+    const fn = t.function || t;
+    const name = fn.name;
+    const category = toolClusterMap.get(name) || (name.startsWith('mcp_') ? 'MCP' : 'CATALOG');
+    return {
+      name,
+      description: fn.description || '',
+      category,
+      isMcpExposed: mcpToolSet.has(name),
+      isExternalMcp: name.startsWith('mcp_'),
+      parameters: fn.parameters || fn.inputSchema || { type: 'object', properties: {} }
+    };
+  });
+
+  const categories = {
+    ALL: tools.length,
+    CATALOG: tools.filter(t => t.category === 'CATALOG').length,
+    MEDIA: tools.filter(t => t.category === 'MEDIA').length,
+    RESEARCH: tools.filter(t => t.category === 'RESEARCH').length,
+    SYSTEM: tools.filter(t => t.category === 'SYSTEM').length,
+    MCP: tools.filter(t => t.category === 'MCP' || t.isExternalMcp).length,
+  };
+
+  const connectedServers = currentAgent?.mcpManager?.servers 
+    ? Array.from(currentAgent.mcpManager.servers.keys())
+    : [];
+  const importedTools = currentAgent?.mcpManager?.toolRegistry
+    ? Array.from(currentAgent.mcpManager.toolRegistry.keys())
+    : [];
+
+  const clientConfigs = buildMcpClientConfigs(baseUrl);
+
+  return sendJson(res, 200, {
+    status: 'ok',
+    timestamp: new Date().toISOString(),
+    mcpServer: {
+      online: true,
+      name: 'kiku',
+      title: 'Kiku Agent MCP Server',
+      version: PACKAGE_VERSION,
+      protocol: 'model-context-protocol',
+      protocolVersion: '2025-11-25',
+      supportedProtocolVersions: ['2025-11-25', '2025-06-18', '2025-03-26', '2024-11-05', '2024-10-07'],
+      transport: 'streamable-http',
+      endpoint: '/mcp',
+      fullUrl: `${baseUrl}/mcp`,
+      toolsCount: mcpToolDefinitions.length,
+      stats: getMcpSessionStats(),
+      clientConfigs
+    },
+    mcpClient: {
+      supported: true,
+      connectedServersCount: connectedServers.length,
+      connectedServers,
+      importedToolsCount: importedTools.length,
+      importedTools
+    },
+    totalTools: tools.length,
+    categories,
+    tools
+  });
+}

package/server/web-chat/routes/memoryRoute.js

@@ -0,0 +1,253 @@
+import { AgentMemory } from '../../agent/memory.js';
+import { parseJsonBody, sendJson, sendError } from '../core/errorHandler.js';
+import { isWebChatAdmin } from '../core/security.js';
+
+const MAX_FACTS_RESPONSE = 200;
+const MAX_CONTENT_LENGTH = 2000;
+
+let store = null;
+let loadPromise = null;
+
+export function setMemoryStore(customStore) {
+  store = customStore;
+  loadPromise = null;
+}
+
+function getStore() {
+  if (!store) store = new AgentMemory();
+  return store;
+}
+
+async function ensureLoaded() {
+  const mem = getStore();
+  if (mem._loaded) return mem;
+  if (!loadPromise) {
+    loadPromise = Promise.resolve()
+      .then(() => mem.load())
+      .catch(() => false)
+      .finally(() => { loadPromise = null; });
+  }
+  await loadPromise;
+  return mem;
+}
+
+function toIsoDate(value) {
+  if (!value) return null;
+  try {
+    const date = value instanceof Date ? value : new Date(value);
+    return Number.isNaN(date.getTime()) ? null : date.toISOString();
+  } catch {
+    return null;
+  }
+}
+
+function serializeFact(fact = {}) {
+  return {
+    id: String(fact.id || ''),
+    content: String(fact.content || ''),
+    category: String(fact.category || 'general'),
+    source: String(fact.source || 'conversation'),
+    confidence: fact.confidence ?? 'high',
+    tags: Array.isArray(fact.tags) ? fact.tags.map(t => String(t)) : [],
+    accessCount: Number(fact.accessCount) || 0,
+    createdAt: toIsoDate(fact.createdAt),
+    lastAccessedAt: toIsoDate(fact.lastAccessedAt),
+  };
+}
+
+function serializeSession(s = {}) {
+  const summary = s?.summary || null;
+  const firstQuestion = summary && Array.isArray(summary.keyExchanges)
+    ? summary.keyExchanges.find(x => x?.question)
+    : null;
+  return {
+    id: String(s?.id || ''),
+    messageCount: Number(s?.messageCount) || 0,
+    createdAt: toIsoDate(s?.createdAt),
+    endedAt: toIsoDate(s?.endedAt),
+    hasSummary: Boolean(summary),
+    topics: summary && Array.isArray(summary.topics) ? summary.topics.map(t => String(t)).slice(0, 8) : [],
+    preview: firstQuestion?.question ? String(firstQuestion.question).slice(0, 160) : null,
+    questionCount: summary?.questionCount ?? null,
+    durationMs: summary?.durationMs ?? null,
+    toolCalls: summary?.toolCalls ?? null,
+  };
+}
+
+function extractSessionExchanges(messages = [], limit = 5) {
+  const exchanges = [];
+  let pendingQuestion = null;
+  for (const m of Array.isArray(messages) ? messages : []) {
+    if (!m || typeof m !== 'object') continue;
+    const textPart = Array.isArray(m.parts) ? m.parts.find(p => p && p.type === 'text') : null;
+    const text = String(textPart?.content || m.content || m.text || '').trim();
+    if (!text) continue;
+    if (m.role === 'user') {
+      if (exchanges.length >= limit) break;
+      if (pendingQuestion) exchanges.push({ question: pendingQuestion, answerPreview: '' });
+      pendingQuestion = text.slice(0, 300);
+    } else if (m.role === 'assistant' && pendingQuestion) {
+      exchanges.push({ question: pendingQuestion, answerPreview: text.slice(0, 300) });
+      pendingQuestion = null;
+    }
+  }
+  if (pendingQuestion && exchanges.length < limit) {
+    exchanges.push({ question: pendingQuestion, answerPreview: '' });
+  }
+  return exchanges;
+}
+
+function sanitizeCategory(value) {
+  const cleaned = String(value || '').trim().toLowerCase().replace(/[^a-z0-9_-]+/g, '').slice(0, 40);
+  return cleaned || 'general';
+}
+
+function sanitizeTags(value) {
+  if (!Array.isArray(value)) return [];
+  return value
+    .map(t => String(t || '').trim().slice(0, 30))
+    .filter(Boolean)
+    .slice(0, 10);
+}
+
+function sanitizeId(value) {
+  const id = String(value || '').trim();
+  if (!id || id.length > 120 || !/^[A-Za-z0-9_-]+$/.test(id)) return null;
+  return id;
+}
+
+export async function handleMemoryGetRoute(req, res) {
+  const mem = await ensureLoaded();
+  const facts = Array.isArray(mem.facts) ? mem.facts : [];
+  const status = typeof mem.getStatus === 'function' ? mem.getStatus() : {};
+  sendJson(res, 200, {
+    status: 'ok',
+    persistent: Boolean(mem.persistenceEnabled && !mem._storageError),
+    storageError: mem._storageError ? String(mem._storageError.code || mem._storageError.message || mem._storageError) : null,
+    factsCount: facts.length,
+    sessionsCount: Array.isArray(mem.sessions) ? mem.sessions.length : 0,
+    summariesCount: Array.isArray(mem.summaries) ? mem.summaries.length : 0,
+    factsByCategory: status.factsByCategory || {},
+    topTopics: Array.isArray(status.topTopics) ? status.topTopics : [],
+    totalFacts: facts.length,
+    facts: facts.slice(-MAX_FACTS_RESPONSE).map(serializeFact).reverse(),
+    sessions: (Array.isArray(mem.sessions) ? mem.sessions : []).slice(-50).map(serializeSession).reverse(),
+  });
+}
+
+export async function handleMemoryActionRoute(req, res) {
+  let body;
+  try {
+    body = await parseJsonBody(req, 64 * 1024);
+  } catch (err) {
+    return sendError(res, 400, `Invalid JSON body: ${err.message}`);
+  }
+
+  const action = String(body.action || '').toLowerCase();
+  const mem = await ensureLoaded();
+
+  if (action === 'add') {
+    const content = String(body.content || '').trim();
+    if (!content) return sendError(res, 400, 'content is required');
+    if (content.length > MAX_CONTENT_LENGTH) {
+      return sendError(res, 400, `content too long (max ${MAX_CONTENT_LENGTH} chars)`);
+    }
+    const entry = mem.addFact(content, {
+      category: sanitizeCategory(body.category),
+      tags: sanitizeTags(body.tags),
+      source: 'web-settings',
+    });
+    if (!entry) return sendError(res, 500, 'Failed to store fact');
+    return sendJson(res, 200, { status: 'ok', fact: serializeFact(entry), factsCount: mem.facts.length });
+  }
+
+  if (action === 'delete') {
+    const id = sanitizeId(body.id);
+    if (!id) return sendError(res, 400, 'valid id is required');
+    if (!mem.removeFact(id)) return sendError(res, 404, `Fact not found: ${id}`);
+    return sendJson(res, 200, { status: 'ok', id, factsCount: mem.facts.length });
+  }
+
+  if (action === 'search') {
+    const query = String(body.query || '').trim().slice(0, 500);
+    const limit = Math.min(Math.max(Number(body.limit) || 20, 1), 50);
+    const results = mem.searchFacts(query, { limit });
+    return sendJson(res, 200, {
+      status: 'ok',
+      query,
+      count: results.length,
+      facts: results.map(serializeFact),
+    });
+  }
+
+  if (action === 'session_summary') {
+    const sessionId = sanitizeId(body.sessionId);
+    if (!sessionId) return sendError(res, 400, 'valid sessionId is required');
+    let session = null;
+    try {
+      session = await mem.loadArchivedSession(sessionId);
+    } catch {
+      session = null;
+    }
+    if (!session || typeof session !== 'object') {
+      return sendError(res, 404, `Session not found or not archived: ${sessionId}`);
+    }
+    const summaryFromMemory = Array.isArray(mem.summaries)
+      ? mem.summaries.find(s => s?.sessionId === sessionId) || null
+      : null;
+    const summarySource = session.summary || summaryFromMemory;
+    const messages = Array.isArray(session.messages) ? session.messages : [];
+    const userMessageCount = messages.filter(m => m?.role === 'user').length;
+    const exchanges = extractSessionExchanges(messages, 5);
+    const fallbackExchanges = Array.isArray(summarySource?.keyExchanges)
+      ? summarySource.keyExchanges.slice(0, 5).map(x => ({
+        question: String(x?.question || '').slice(0, 300),
+        answerPreview: String(x?.answerPreview || '').slice(0, 300),
+      }))
+      : [];
+    const stats = session.stats && typeof session.stats === 'object' ? session.stats : {};
+    return sendJson(res, 200, {
+      status: 'ok',
+      sessionId,
+      messageCount: messages.length || Number(session.messageCount) || 0,
+      createdAt: toIsoDate(session.createdAt),
+      endedAt: toIsoDate(session.endedAt),
+      thinkingMode: session.thinkingMode ? String(session.thinkingMode) : null,
+      stats: (Number(stats.totalDurationMs) || Number(stats.totalToolCalls))
+        ? {
+          totalDurationMs: Number(stats.totalDurationMs) || 0,
+          totalToolCalls: Number(stats.totalToolCalls) || 0,
+        }
+        : null,
+      summary: {
+        topics: Array.isArray(summarySource?.topics) ? summarySource.topics.map(t => String(t)).slice(0, 10) : [],
+        questionCount: userMessageCount || Number(summarySource?.questionCount) || 0,
+        durationMs: Number(summarySource?.durationMs) || Number(stats.totalDurationMs) || 0,
+        toolCalls: Number(summarySource?.toolCalls) || Number(stats.totalToolCalls) || 0,
+        keyExchanges: exchanges.length ? exchanges : fallbackExchanges,
+      },
+    });
+  }
+
+  if (action === 'export') {
+    const facts = Array.isArray(mem.facts) ? mem.facts : [];
+    return sendJson(res, 200, {
+      status: 'ok',
+      exportedAt: new Date().toISOString(),
+      facts: facts.map(serializeFact),
+      preferences: mem.preferences || {},
+      sessionsCount: Array.isArray(mem.sessions) ? mem.sessions.length : 0,
+      summariesCount: Array.isArray(mem.summaries) ? mem.summaries.length : 0,
+    });
+  }
+
+  if (action === 'clear') {
+    if (!isWebChatAdmin(req)) {
+      return sendError(res, 401, 'Admin API key required to wipe memory');
+    }
+    await mem.clearAll();
+    return sendJson(res, 200, { status: 'ok', factsCount: 0 });
+  }
+
+  return sendError(res, 400, 'action must be one of: add, delete, search, session_summary, export, clear');
+}