kiku-agent 1.0.11 → 1.2.0

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

@@ -0,0 +1,59 @@
+import { normalizeWebSessionId } from '../core/connection.js';
+import { parseJsonBody, sendJson, sendError } from '../core/errorHandler.js';
+
+export async function handleExportRoute(req, res) {
+  let body;
+  try {
+    body = await parseJsonBody(req);
+  } catch (err) {
+    return sendError(res, 400, `Invalid JSON body: ${err.message}`);
+  }
+
+  const { sessionId, format = 'markdown', history = [] } = body;
+  const normSessionId = normalizeWebSessionId(sessionId);
+  const now = new Date().toISOString().replace(/[:.]/g, '-');
+  const filename = `kiku-chat-${normSessionId || 'session'}-${now}`;
+
+  if (format === 'json') {
+    const exportData = {
+      exportedAt: new Date().toISOString(),
+      sessionId: normSessionId,
+      messages: history,
+      metadata: { app: '鞠婧祎', version: '1.0.0' }
+    };
+    res.writeHead(200, {
+      'Content-Type': 'application/json; charset=utf-8',
+      'Content-Disposition': `attachment; filename="${filename}.json"`
+    });
+    res.end(JSON.stringify(exportData, null, 2));
+    return;
+  }
+
+  if (format === 'html') {
+    const msgHtml = history.map(m => {
+      const role = m.role === 'user' ? '🧑 You' : '🌸 Kiku';
+      const escaped = String(m.text || m.content || '').replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+      return `<div style="margin:12px 0;padding:12px;border-radius:8px;background:${m.role === 'user' ? '#e3f2fd' : '#fce4ec'}"><strong>${role}:</strong><br><pre style="white-space:pre-wrap;margin:4px 0 0;font-family:inherit">${escaped}</pre></div>`;
+    }).join('\n');
+    const html = `<!DOCTYPE html><html lang="en"><head><meta charset="UTF-8"><title>Kiku Chat Export</title><style>body{font-family:sans-serif;max-width:800px;margin:40px auto;padding:0 20px}h1{color:#e91e63}</style></head><body><h1>🌸 Kiku AI Chat Export</h1><p>Session: ${normSessionId || 'N/A'} | Exported: ${new Date().toLocaleString()}</p><hr>${msgHtml}</body></html>`;
+    res.writeHead(200, {
+      'Content-Type': 'text/html; charset=utf-8',
+      'Content-Disposition': `attachment; filename="${filename}.html"`
+    });
+    res.end(html);
+    return;
+  }
+
+  let md = `# 🌸 Kiku AI Chat Export\n\n`;
+  md += `- **Session:** ${normSessionId || 'N/A'}\n`;
+  md += `- **Exported:** ${new Date().toLocaleString()}\n\n---\n\n`;
+  history.forEach(m => {
+    const role = m.role === 'user' ? '🧑 **You**' : '🌸 **Kiku**';
+    md += `### ${role}\n\n${m.text || m.content || ''}\n\n---\n\n`;
+  });
+  res.writeHead(200, {
+    'Content-Type': 'text/markdown; charset=utf-8',
+    'Content-Disposition': `attachment; filename="${filename}.md"`
+  });
+  res.end(md);
+}

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

@@ -0,0 +1,57 @@
+import { parseJsonBody, sendJson, sendError } from '../core/errorHandler.js';
+import { FeedbackLearning } from '../../agent/feedbackLearning.js';
+import { isWebChatAdmin } from '../core/security.js';
+
+let store = null;
+
+export function setFeedbackStore(customStore) {
+  store = customStore;
+}
+
+function getStore() {
+  if (!store) store = new FeedbackLearning({ persistence: false });
+  return store;
+}
+
+export async function handleFeedbackRoute(req, res) {
+  let body;
+  try {
+    body = await parseJsonBody(req, 64 * 1024);
+  } catch (err) {
+    return sendError(res, 400, `Invalid JSON body: ${err.message}`);
+  }
+
+  const rating = String(body.rating || '').toLowerCase();
+  if (rating !== 'like' && rating !== 'dislike') {
+    return sendError(res, 400, 'rating must be "like" or "dislike".');
+  }
+
+  let result;
+  try {
+    result = getStore().record({
+      rating,
+      query: body.query,
+      answer: body.answer,
+      toolsUsed: body.tools,
+      model: body.model,
+      sessionId: body.sessionId,
+      messageId: body.messageId,
+    });
+  } catch (err) {
+    return sendError(res, 400, err.message);
+  }
+
+  sendJson(res, 200, {
+    status: 'ok',
+    rating,
+    totals: result.totals,
+    directives: result.directives,
+    learnedCount: 0,
+  });
+}
+
+export async function handleFeedbackStatsRoute(req, res) {
+  if (!isWebChatAdmin(req)) return sendError(res, 401, 'Admin API key required');
+  const stats = getStore().getStats();
+  sendJson(res, 200, { status: 'ok', ...stats });
+}

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

@@ -0,0 +1,33 @@
+import { socialUpdatesData } from '../../../src/data/socialUpdatesData.js';
+import { parseJsonBody, sendJson, sendError } from '../core/errorHandler.js';
+
+export async function handleNewsRoute(req, res) {
+  let body = {};
+  try {
+    body = await parseJsonBody(req);
+  } catch {}
+
+  const { query = 'จวีจิ้งอี Ju Jingyi', days = 30 } = body;
+  let newsItems = [];
+  const source = 'social';
+
+  try {
+    const cards = socialUpdatesData?.douyin?.cards || socialUpdatesData?.cards || [];
+    newsItems = cards.map(c => ({
+      title: c.title || c.titleCn,
+      summary: c.captionTh || c.captionCn || c.content,
+      date: c.date,
+      platform: c.platform,
+      videoUrl: c.videoUrl
+    }));
+  } catch {}
+
+  sendJson(res, 200, {
+    status: 'ok',
+    query,
+    days,
+    items: newsItems.slice(0, 10),
+    source,
+    count: newsItems.length
+  });
+}

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

@@ -0,0 +1,11 @@
+import { QUIZ_QUESTIONS, shuffleQuizQuestions } from '../../agent/quizData.js';
+import { sendJson } from '../core/errorHandler.js';
+
+export async function handleQuizRoute(req, res) {
+  const shuffledQuestions = shuffleQuizQuestions(QUIZ_QUESTIONS);
+  sendJson(res, 200, {
+    status: 'ok',
+    questions: shuffledQuestions
+  });
+}
+

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

@@ -0,0 +1,103 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { getWebChatHtml } from '../ui/htmlBuilder.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const PUBLIC_DIR = path.resolve(__dirname, '../../../public');
+
+const MIME_TYPES = {
+  '.woff2': 'font/woff2',
+  '.woff': 'font/woff',
+  '.ttf': 'font/ttf',
+  '.css': 'text/css; charset=utf-8',
+  '.js': 'application/javascript; charset=utf-8',
+  '.mjs': 'application/javascript; charset=utf-8',
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.webp': 'image/webp',
+  '.gif': 'image/gif',
+  '.svg': 'image/svg+xml',
+  '.mp4': 'video/mp4',
+  '.json': 'application/json; charset=utf-8',
+  '.txt': 'text/plain; charset=utf-8'
+};
+
+export function handleStaticRoute(req, res, pathname, port) {
+  if (pathname === '/favicon.ico' || pathname === '/favicon.svg') {
+    const svgIcon = `<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 100 100'><text y='.9em' font-size='90'>🌸</text></svg>`;
+    res.writeHead(200, {
+      'Content-Type': 'image/svg+xml',
+      'Cache-Control': 'public, max-age=86400, immutable'
+    });
+    res.end(svgIcon);
+    return true;
+  }
+
+  if (pathname === '/sw.js' || pathname === '/service-worker.js') {
+    let swPath = path.join(PUBLIC_DIR, 'sw.js');
+    if (!fs.existsSync(swPath)) {
+      const cwdPath = path.join(process.cwd(), 'public', 'sw.js');
+      if (fs.existsSync(cwdPath)) swPath = cwdPath;
+    }
+    res.writeHead(200, {
+      'Content-Type': 'application/javascript; charset=utf-8',
+      'Service-Worker-Allowed': '/',
+      'Cache-Control': 'no-cache, no-store, must-revalidate'
+    });
+    if (fs.existsSync(swPath)) {
+      fs.createReadStream(swPath).pipe(res);
+    } else {
+      res.end(`const CACHE_NAME = 'kiku-v1';
+const ASSETS = ['/', '/manifest.json'];
+self.addEventListener('install', (event) => {
+  event.waitUntil(caches.open(CACHE_NAME).then((cache) => cache.addAll(ASSETS)).then(() => self.skipWaiting()));
+});
+self.addEventListener('activate', (event) => {
+  event.waitUntil(caches.keys().then((keys) => Promise.all(keys.filter((k) => k !== CACHE_NAME).map((k) => caches.delete(k)))).then(() => self.clients.claim()));
+});
+self.addEventListener('fetch', (event) => {
+  if (event.request.url.includes('/api/')) return;
+  event.respondWith(caches.match(event.request).then((cached) => cached || fetch(event.request).then((response) => {
+    if (response.ok && event.request.method === 'GET') {
+      const clone = response.clone();
+      caches.open(CACHE_NAME).then((cache) => cache.put(event.request, clone));
+    }
+    return response;
+  }).catch(() => cached)));
+});`);
+    }
+    return true;
+  }
+
+  if (pathname.startsWith('/fonts/') || pathname.startsWith('/images/') || pathname === '/manifest.json' || pathname === '/robots.txt') {
+    const safePath = path.normalize(pathname).replace(/^(\.\.[\/\\])+/, '');
+    let filePath = path.join(PUBLIC_DIR, safePath);
+    if (!fs.existsSync(filePath)) {
+      const cwdPath = path.join(process.cwd(), 'public', safePath);
+      if (fs.existsSync(cwdPath)) filePath = cwdPath;
+    }
+    if (fs.existsSync(filePath) && fs.statSync(filePath).isFile()) {
+      const ext = path.extname(filePath).toLowerCase();
+      res.writeHead(200, {
+        'Content-Type': MIME_TYPES[ext] || 'application/octet-stream',
+        'Cache-Control': ext === '.json' || ext === '.txt' ? 'no-cache' : 'public, max-age=31536000, immutable'
+      });
+      fs.createReadStream(filePath).pipe(res);
+      return true;
+    }
+  }
+
+  if (pathname === '/' || pathname === '/chat' || pathname.startsWith('/chat/') || pathname === '/index.html') {
+    res.writeHead(200, {
+      'Content-Type': 'text/html; charset=utf-8',
+      'Cache-Control': 'no-cache, no-store, must-revalidate'
+    });
+    res.end(getWebChatHtml(port));
+    return true;
+  }
+
+  return false;
+}

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

@@ -0,0 +1,52 @@
+import { toolsSchema } from '../../agent/tools.js';
+import { resolveAgentConnection } from '../core/connection.js';
+import { getAgentMemorySnapshot } from '../core/memorySnapshot.js';
+import { sendJson, sendError } from '../core/errorHandler.js';
+import { extractApiKey } from '../core/security.js';
+
+export async function handleStatusRoute(req, res, urlObj, port) {
+  try {
+    const queryProvider = urlObj.searchParams.get('provider');
+    const queryModel = urlObj.searchParams.get('model');
+    const queryApiKey = extractApiKey(req);
+    const querySessionId = urlObj.searchParams.get('sessionId');
+
+    const conn = await resolveAgentConnection({
+      provider: queryProvider,
+      model: queryModel,
+      apiKey: queryApiKey,
+      sessionId: querySessionId,
+    });
+
+    const totalTools = conn.agent?.getAllToolsSchema?.().length || toolsSchema.length;
+
+    sendJson(res, 200, {
+      status: 'ok',
+      server: 'Kiku Web Chatbot',
+      port,
+      connected: conn.ready,
+      state: conn.ready ? 'ready' : (conn.state || 'server_offline'),
+      provider: conn.provider,
+      model: conn.model,
+      activeModel: conn.model,
+      activeLoadedModel: conn.resolution?.activeLoadedModel || conn.model,
+      loadedModels: conn.models || [],
+      usedFallback: conn.usedFallback || false,
+      error: conn.error || null,
+      capabilities: {
+        reactAgent: Boolean(conn.agent),
+        streaming: true,
+        toolCalling: Boolean(conn.agent),
+        localTools: toolsSchema.length,
+        mcpTools: Math.max(0, totalTools - toolsSchema.length),
+        totalTools,
+        sessionMemory: Boolean(conn.agent),
+        longTermMemory: Boolean(conn.agent?.memory),
+        cachedAgent: conn.cached === true,
+      },
+      memory: getAgentMemorySnapshot(conn.agent, querySessionId)
+    });
+  } catch (err) {
+    sendError(res, 500, err.message);
+  }
+}

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

@@ -0,0 +1,77 @@
+import { executeTool } from '../../agent/tools.js';
+import { CATEGORIZED_SUGGESTIONS, DEFAULT_SUGGESTIONS } from '../ui/scripts/suggestionsData.js';
+import { resolveAgentConnection } from '../core/connection.js';
+import { parseJsonBody, sendJson, sendError } from '../core/errorHandler.js';
+import { extractApiKey } from '../core/security.js';
+
+export async function handleSuggestionsRoute(req, res) {
+  sendJson(res, 200, {
+    suggestions: DEFAULT_SUGGESTIONS,
+    categories: CATEGORIZED_SUGGESTIONS
+  });
+}
+
+const AI_SUGGEST_LANGS = new Set(['th', 'zh', 'en', 'ja', 'ko']);
+
+function normalizeAiSuggestions(raw) {
+  const list = Array.isArray(raw) ? raw : [];
+  const out = [];
+  for (const item of list) {
+    const q = typeof item === 'string' ? item : (item?.question || item?.query || item?.text || '');
+    const clean = String(q || '').replace(/\*\*(.+?)\*\*/g, '$1').trim();
+    if (clean.length > 3 && out.length < 8 && !out.includes(clean)) out.push(clean);
+  }
+  return out;
+}
+
+export async function handleAiSuggestRoute(req, res) {
+  let body = {};
+  try {
+    body = await parseJsonBody(req);
+  } catch {}
+
+  const { topic = '' } = body;
+  const limit = Math.min(Math.max(Number(body.limit) || 5, 2), 8);
+  const lang = AI_SUGGEST_LANGS.has(String(body.lang || '').toLowerCase())
+    ? String(body.lang).toLowerCase()
+    : 'en';
+  let suggestions = [];
+  let source = 'curated';
+
+  try {
+    const apiKey = extractApiKey(req);
+    const conn = await resolveAgentConnection({
+      provider: body.provider,
+      model: body.model,
+      apiKey,
+      sessionId: body.sessionId,
+    });
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 30000);
+    try {
+      if (conn.ready && conn.agent?.generateSuggestions) {
+        const toolResult = await executeTool(
+          'suggest_topics',
+          { topic: topic || undefined, limit, lang },
+          { agent: conn.agent, signal: controller.signal }
+        );
+        suggestions = normalizeAiSuggestions(toolResult?.suggestions || toolResult?.topics);
+        if (suggestions.length > 0) source = 'ai';
+      }
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  } catch {}
+
+  if (suggestions.length === 0) {
+    suggestions = DEFAULT_SUGGESTIONS.slice(0, 8);
+  }
+
+  sendJson(res, 200, {
+    status: 'ok',
+    suggestions,
+    topic: topic || null,
+    lang,
+    source
+  });
+}

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

@@ -0,0 +1,34 @@
+import { timelineData } from '../../../src/data/timelineData.js';
+import { sendJson } from '../core/errorHandler.js';
+
+export async function handleTimelineRoute(req, res, urlObj) {
+  if (req.method !== 'GET') {
+    sendJson(res, 405, { status: 'error', error: 'Method not allowed' });
+    return;
+  }
+
+  const year = urlObj.searchParams.get('year') || '';
+  const era = (urlObj.searchParams.get('era') || '').toLowerCase();
+  const category = (urlObj.searchParams.get('category') || '').toLowerCase();
+  const search = (urlObj.searchParams.get('search') || urlObj.searchParams.get('q') || '').toLowerCase();
+
+  let results = [...timelineData];
+  if (year) results = results.filter(item => String(item.year).includes(year));
+  if (era) results = results.filter(item => String(item.era || '').toLowerCase().includes(era));
+  if (category) results = results.filter(item => String(item.category || '').toLowerCase().includes(category));
+  if (search) {
+    results = results.filter(item => [item.title, item.titleCn, item.summary, item.badge]
+      .some(value => String(value || '').toLowerCase().includes(search)));
+  }
+
+  sendJson(res, 200, {
+    status: 'success',
+    code: 200,
+    timestamp: new Date().toISOString(),
+    data: results,
+    meta: {
+      totalMilestones: timelineData.length,
+      filteredCount: results.length
+    }
+  });
+}

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

@@ -0,0 +1,57 @@
+import { executeTool } from '../../agent/tools.js';
+import { parseJsonBody, sendJson, sendError } from '../core/errorHandler.js';
+
+export async function handleVerifyRoute(req, res) {
+  let body;
+  try {
+    body = await parseJsonBody(req);
+  } catch (err) {
+    return sendError(res, 400, `Invalid JSON body: ${err.message}`);
+  }
+
+  const { claim } = body;
+  if (!claim) {
+    return sendError(res, 400, 'Claim is required');
+  }
+
+  let result = null;
+
+  try {
+    const searchResult = await executeTool('global_search', { query: claim });
+    const rawResults = searchResult?.results;
+    const flatItems = Array.isArray(rawResults)
+      ? rawResults
+      : Object.values(rawResults || {}).flat().filter(item => typeof item === 'object');
+
+    const hasDirectMatch = flatItems.some(r =>
+      String(r.title || r.name || '').toLowerCase().includes(claim.toLowerCase()) ||
+      String(r.description || r.synopsis || '').toLowerCase().includes(claim.toLowerCase())
+    );
+
+    result = {
+      verdict: hasDirectMatch ? 'PARTIALLY_VERIFIED' : 'UNVERIFIED',
+      claim,
+      evidence: flatItems.slice(0, 3),
+      note: hasDirectMatch
+        ? 'A related entry was found in the Ju Jingyi knowledge graph; review the evidence before relying on the claim.'
+        : 'No supporting entry was found in the Ju Jingyi knowledge graph.'
+    };
+  } catch {
+    result = {
+      verdict: 'UNKNOWN',
+      claim,
+      evidence: [],
+      note: 'Verification could not be completed. Treat the claim as unverified.'
+    };
+  }
+
+  sendJson(res, 200, {
+    status: 'ok',
+    claim,
+    verdict: result.verdict || result.verdicts?.[0] || 'UNKNOWN',
+    confidence: result.confidence || (result.verdict === 'PARTIALLY_VERIFIED' ? 'medium' : 'low'),
+    evidence: result.evidence || result.supporting || result.counter || [],
+    detail: result.detail || result.analysis || result.note || null,
+    durationMs: result.durationMs || 0
+  });
+}

package/server/web-chat/server.js

@@ -0,0 +1,116 @@
+import http from 'node:http';
+import { handleWebChatRequest } from './router.js';
+import { currentAgent, setCurrentAgent, webAgentCache } from './core/connection.js';
+import { config } from '../agent/config.js';
+
+let activeServer = null;
+let activePort = Number(process.env.PORT_WEB_CHAT || 3300);
+let activeHost = process.env.KIKU_WEB_CHAT_HOST || '127.0.0.1';
+
+export function getWebChatServerStatus() {
+  if (!activeServer) {
+    return {
+      running: false,
+      port: activePort,
+      url: `http://${activeHost}:${activePort}`,
+    };
+  }
+  return {
+    running: true,
+    port: activePort,
+    url: `http://${activeHost}:${activePort}`,
+    provider: currentAgent?.client?.provider || config.activeProvider || 'lmstudio',
+    model: currentAgent?.client?.model || 'google/gemma-4-e4b',
+  };
+}
+
+export function stopWebChatServer() {
+  return new Promise((resolve) => {
+    if (!activeServer) return resolve(false);
+    if (typeof activeServer.closeAllConnections === 'function') {
+      try { activeServer.closeAllConnections(); } catch {}
+    }
+    activeServer.close(async () => {
+      await Promise.allSettled(
+        Array.from(webAgentCache.values(), connection => connection.agent?.saveSession?.())
+      );
+      webAgentCache.clear();
+      activeServer = null;
+      resolve(true);
+    });
+  });
+}
+
+function getNextSafePort(port) {
+  // If in Windows Hyper-V / WSL TCP excluded port range (2943..3142 or 5388..5587), jump past it
+  if (port >= 2940 && port <= 3150) {
+    return 3300;
+  }
+  if (port >= 5380 && port <= 5590) {
+    return 5600;
+  }
+  return port + 1;
+}
+
+export async function startWebChatServer(options = {}) {
+  const requestedPort = Number(options.port || process.env.PORT_WEB_CHAT || 3300);
+  const requestedHost = String(options.host || process.env.KIKU_WEB_CHAT_HOST || '127.0.0.1');
+  const isLoopback = requestedHost === '127.0.0.1' || requestedHost === '::1' || requestedHost === 'localhost';
+  if (!isLoopback && process.env.KIKU_ALLOW_REMOTE_WEB_CHAT !== 'true') {
+    throw new Error('Remote web-chat binding is disabled. Set KIKU_ALLOW_REMOTE_WEB_CHAT=true only behind an authenticated reverse proxy.');
+  }
+  if (options.agent) {
+    setCurrentAgent(options.agent);
+  }
+
+  if (activeServer) {
+    if (options.port && activePort !== Number(options.port)) {
+      await stopWebChatServer();
+    } else {
+      return Promise.resolve({
+        server: activeServer,
+        port: activePort,
+        url: `http://${activeHost}:${activePort}`,
+        alreadyRunning: true
+      });
+    }
+  }
+
+  return new Promise((resolve, reject) => {
+    let currentPort = requestedPort;
+    let attempts = 0;
+    const maxAttempts = 15;
+    let server = null;
+
+    function tryBind() {
+      server = http.createServer(async (req, res) => {
+        await handleWebChatRequest(req, res, { port: activePort });
+      });
+
+      server.on('error', (err) => {
+        if ((err.code === 'EACCES' || err.code === 'EADDRINUSE') && attempts < maxAttempts) {
+          attempts++;
+          currentPort = getNextSafePort(currentPort);
+          try { server.close(); } catch {}
+          setTimeout(tryBind, 20);
+          return;
+        }
+        reject(err);
+      });
+
+      server.listen(currentPort, requestedHost, () => {
+        activeServer = server;
+        activePort = currentPort;
+        activeHost = requestedHost;
+        resolve({
+          server,
+          port: activePort,
+          url: `http://${activeHost}:${activePort}`,
+          alreadyRunning: false
+        });
+      });
+    }
+
+    tryBind();
+  });
+}