kiku-agent 1.0.0

package/server/agent/sanitizer.js

@@ -0,0 +1,314 @@
+import path from 'node:path';
+
+
+
+const MAX_QUERY_LENGTH = 4096;
+const MAX_PATH_LENGTH = 1024;
+const MAX_URL_LENGTH = 2048;
+const MAX_TOOL_ARGS_SIZE = 8192;
+
+
+const SHELL_META_CHARS = /[;&|`$(){}[\]!#~<>\\]/;
+
+
+const SHELL_COMMAND_PATTERNS = [
+  /\brm\s+-rf\b/i,
+  /\bmkfs\b/i,
+  /\bdd\s+if=/i,
+  /\bchmod\s+/i,
+  /\bchown\s+/i,
+  /\bsudo\s+/i,
+  /\bdoas\s+/i,
+  /\bexec\s*\(/i,
+  /\beval\s*\(/i,
+  /\bchild_process\b/i,
+  /\bspawn\s*\(/i,
+  /\brequire\s*\(\s*['"]child_process/i,
+  /\bos\.system\b/i,
+  /\bsubprocess\b/i,
+  /\bsystem\s*\(/i,
+];
+
+
+const PROMPT_INJECTION_PATTERNS = [
+  /ignore\s+(all\s+)?(previous|above|prior)\s+(instructions|prompts|rules)/i,
+  /you\s+are\s+now\s+(a|an)\s+/i,
+  /new\s+system\s+prompt/i,
+  /disregard\s+(all\s+)?(previous|above)/i,
+  /override\s+(system|instructions)/i,
+  /\[SYSTEM\]\s*/i,
+  /<<SYS>>/i,
+  /<\/s>/i,
+];
+
+
+const SAFE_PROTOCOLS = ['http:', 'https:'];
+
+const BLOCKED_HOST_PATTERNS = [
+  /^localhost$/i,
+  /^127\./,
+  /^10\./,
+  /^172\.(1[6-9]|2\d|3[01])\./,
+  /^192\.168\./,
+  /^0\.0\.0\.0$/,
+  /^::$/,
+  /^::1$/,
+  /^0:0:0:0:0:0:0:1$/,
+  /^fe80:/i,
+  /^(?:fc|fd)[0-9a-f]{2}:/i,
+  /^::ffff:(?:127\.|10\.|192\.168\.|172\.(?:1[6-9]|2\d|3[01])\.)/i,
+  /^::ffff:(?:7f[0-9a-f]{2}|a[0-9a-f]{2}|c0a8|ac1[0-9a-f]|a9fe):/i,
+  /\bmetadata\.google/i,   
+  /\b169\.254\.169\.254/,  
+];
+
+
+const DANGEROUS_EXTENSIONS = new Set([
+  '.sh', '.bash', '.zsh', '.ps1', '.cmd', '.bat', '.exe', '.msi',
+  '.com', '.scr', '.pif', '.vbs', '.vbe', '.js', '.jse', '.wsf',
+  '.wsh', '.reg',
+]);
+
+
+export function stripAnsi(str) {
+  if (typeof str !== 'string') return '';
+  return str.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '')
+            .replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g, '');
+}
+
+
+export function sanitizeQuery(query) {
+  const warnings = [];
+
+  if (typeof query !== 'string') {
+    return { sanitized: '', warnings: ['Query must be a string'] };
+  }
+
+  let sanitized = stripAnsi(query).trim();
+
+ 
+  if (sanitized.length > MAX_QUERY_LENGTH) {
+    warnings.push(`Query truncated from ${sanitized.length} to ${MAX_QUERY_LENGTH} chars`);
+    sanitized = sanitized.slice(0, MAX_QUERY_LENGTH);
+  }
+
+ 
+  for (const pattern of PROMPT_INJECTION_PATTERNS) {
+    if (pattern.test(sanitized)) {
+      warnings.push(`Possible prompt injection detected: ${pattern.source.slice(0, 40)}`);
+      break;
+    }
+  }
+
+ 
+  for (const pattern of SHELL_COMMAND_PATTERNS) {
+    if (pattern.test(sanitized)) {
+      warnings.push(`Suspicious shell pattern detected: ${pattern.source.slice(0, 40)}`);
+      break;
+    }
+  }
+
+  return { sanitized, warnings };
+}
+
+
+export function sanitizeFilePath(filePath, projectRoot = process.cwd(), { blockDangerousExtensions = true } = {}) {
+  if (typeof filePath !== 'string' || !filePath.trim()) {
+    return { safe: false, resolvedPath: '', reason: 'Path is empty or not a string' };
+  }
+
+ 
+  if (filePath.length > MAX_PATH_LENGTH) {
+    return { safe: false, resolvedPath: '', reason: `Path exceeds ${MAX_PATH_LENGTH} chars` };
+  }
+
+  
+  const clean = stripAnsi(filePath).trim();
+
+ 
+  if (clean.includes('\0')) {
+    return { safe: false, resolvedPath: '', reason: 'Path contains null bytes' };
+  }
+
+ 
+  const resolved = path.resolve(projectRoot, clean);
+  const relative = path.relative(projectRoot, resolved);
+
+  if (relative === '..' || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative) || path.isAbsolute(clean)) {
+    return { safe: false, resolvedPath: resolved, reason: 'Path escapes project root (traversal detected)' };
+  }
+
+  if (blockDangerousExtensions) {
+    const normalizedPath = resolved.replace(/[ .]+$/g, '');
+    const extension = path.extname(normalizedPath).toLowerCase();
+    if (DANGEROUS_EXTENSIONS.has(extension)) {
+      return { safe: false, resolvedPath: resolved, reason: `Dangerous file extension blocked: ${extension}` };
+    }
+  }
+
+  return { safe: true, resolvedPath: resolved };
+}
+
+
+export function sanitizeUrl(urlStr) {
+  if (typeof urlStr !== 'string' || !urlStr.trim()) {
+    return { safe: false, reason: 'URL is empty or not a string' };
+  }
+
+  if (urlStr.length > MAX_URL_LENGTH) {
+    return { safe: false, reason: `URL exceeds ${MAX_URL_LENGTH} chars` };
+  }
+
+  const clean = stripAnsi(urlStr).trim();
+
+  let url;
+  try {
+    url = new URL(clean);
+  } catch {
+    return { safe: false, reason: 'Invalid URL format' };
+  }
+
+ 
+  if (!SAFE_PROTOCOLS.includes(url.protocol)) {
+    return { safe: false, reason: `Unsafe protocol: ${url.protocol} (only http/https allowed)` };
+  }
+
+  
+  const hostname = url.hostname.replace(/^\[|\]$/g, '').replace(/\.$/, '').toLowerCase();
+  for (const pattern of BLOCKED_HOST_PATTERNS) {
+    if (pattern.test(hostname)) {
+      return { safe: false, url, reason: `Blocked host (private/internal): ${hostname}` };
+    }
+  }
+
+  return { safe: true, url };
+}
+
+
+export function sanitizeToolArgs(toolName, args) {
+  const warnings = [];
+
+  if (!args || typeof args !== 'object') {
+    return { safe: true, sanitized: {}, warnings };
+  }
+
+  
+  let serialized;
+  try {
+    serialized = JSON.stringify(args);
+  } catch {
+    return { safe: false, sanitized: {}, warnings: ['Args are not serializable'] };
+  }
+
+  if (serialized.length > MAX_TOOL_ARGS_SIZE) {
+    warnings.push(`Tool args truncated from ${serialized.length} to ${MAX_TOOL_ARGS_SIZE} bytes`);
+   
+    const truncated = { ...args };
+    for (const [key, val] of Object.entries(truncated)) {
+      if (typeof val === 'string' && val.length > 1024) {
+        truncated[key] = val.slice(0, 1024) + '…';
+      }
+    }
+    return { safe: true, sanitized: truncated, warnings };
+  }
+
+ 
+  const sanitized = { ...args };
+
+  switch (toolName) {
+    case 'read_local_file':
+    case 'list_directory': {
+      const filePath = sanitized.path || sanitized.filePath;
+      if (filePath) {
+        const check = sanitizeFilePath(filePath, process.cwd(), {
+          blockDangerousExtensions: toolName === 'read_local_file',
+        });
+        if (!check.safe) {
+          return { safe: false, sanitized: {}, warnings: [`Path rejected: ${check.reason}`] };
+        }
+      }
+      break;
+    }
+
+    case 'fetch_webpage':
+    case 'fetch_json':
+    case 'screenshot_webpage': {
+      const url = sanitized.url;
+      if (url) {
+        const check = sanitizeUrl(url);
+        if (!check.safe) {
+          return { safe: false, sanitized: {}, warnings: [`URL rejected: ${check.reason}`] };
+        }
+      }
+      break;
+    }
+
+    case 'fetch_api': {
+    
+      const endpoint = sanitized.endpoint;
+      if (endpoint && typeof endpoint === 'string') {
+        const clean = stripAnsi(endpoint).trim();
+        if (clean.includes('..') || clean.includes('://') || clean.includes('\0')) {
+          return { safe: false, sanitized: {}, warnings: ['Invalid API endpoint path'] };
+        }
+        sanitized.endpoint = clean;
+      }
+      break;
+    }
+
+    case 'play_music':
+    case 'add_to_queue': {
+    
+      const query = sanitized.query;
+      if (query && typeof query === 'string') {
+        const clean = stripAnsi(query).trim();
+    
+        if (SHELL_META_CHARS.test(clean)) {
+          warnings.push('Shell metacharacters stripped from music query');
+          sanitized.query = clean.replace(SHELL_META_CHARS, '');
+        }
+      }
+      break;
+    }
+
+    case 'web_search':
+    case 'web_extract': {
+      const query = sanitized.query;
+      if (query && typeof query === 'string') {
+        sanitized.query = stripAnsi(query).trim().slice(0, 512);
+      }
+      break;
+    }
+  }
+
+  return { safe: true, sanitized, warnings };
+}
+
+
+export function sanitizeResponse(response) {
+  if (typeof response !== 'string') return '';
+
+  
+  const leakPatterns = [
+    /system\s*prompt\s*[:=]/i,
+    /you\s*are\s*(actually|really)\s+(a|an)\s+/i,
+    /my\s*instructions\s*(are|say|tell)/i,
+    /i\s*was\s*(told|instructed|programmed)\s+to/i,
+  ];
+
+  let sanitized = response;
+  for (const pattern of leakPatterns) {
+    if (pattern.test(sanitized)) {
+     
+      break;
+    }
+  }
+
+  return sanitized;
+}
+
+export function isLikelySafe(input) {
+  if (typeof input !== 'string') return false;
+
+  return /^[a-zA-Z0-9\s\-_.,!?'"()（）\u4E00-\u9FA5\u0E00-\u0E7F]+$/.test(input) && input.length < 500;
+}

package/server/agent/session.js

@@ -0,0 +1,239 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+
+const SESSION_DIR = path.resolve(process.cwd(), '.kiku_sessions');
+const SESSION_FILE = path.join(SESSION_DIR, 'current_session.json');
+
+export class AgentSession {
+  constructor(options = {}) {
+    this.id = `sess_${Date.now()}_${Math.random().toString(36).slice(2, 7)}`;
+    this.createdAt = new Date();
+    this.thinkingMode = options.thinkingMode || 'hide';
+    this.messages = [];
+    this.stats = {
+      totalQueries: 0,
+      totalToolCalls: 0,
+      totalDurationMs: 0
+    };
+  }
+
+  setThinkingMode(mode) {
+    if (mode === 'show' || mode === 'hide') {
+      this.thinkingMode = mode;
+      return true;
+    }
+    return false;
+  }
+
+  toggleThinkingMode() {
+    this.thinkingMode = this.thinkingMode === 'show' ? 'hide' : 'show';
+    return this.thinkingMode;
+  }
+
+  createUserMessage(text) {
+    const msg = {
+      id: `msg_${Date.now()}_u`,
+      role: 'user',
+      createdAt: new Date(),
+      parts: [
+        { type: 'text', content: text }
+      ]
+    };
+    this.messages.push(msg);
+    this.stats.totalQueries++;
+   
+    this.saveToDisk().catch(err => console.error('Session save failed:', err));
+    return msg;
+  }
+
+  createAssistantMessage() {
+    const msg = {
+      id: `msg_${Date.now()}_a`,
+      role: 'assistant',
+      createdAt: new Date(),
+      parts: []
+    };
+    this.messages.push(msg);
+    return msg;
+  }
+
+  addReasoningPart(message, reasoningText) {
+    let part = message.parts.find(p => p.type === 'reasoning');
+    if (!part) {
+      part = {
+        type: 'reasoning',
+        id: `rsn_${Date.now()}`,
+        content: '',
+        startedAt: Date.now(),
+        endedAt: null
+      };
+      message.parts.push(part);
+    }
+    part.content += reasoningText;
+    return part;
+  }
+
+  finalizeReasoningPart(message) {
+    const part = message.parts.find(p => p.type === 'reasoning');
+    if (part && !part.endedAt) {
+      part.endedAt = Date.now();
+      part.durationMs = part.endedAt - part.startedAt;
+    }
+  }
+
+  addToolPart(message, toolName, args) {
+    const part = {
+      type: 'tool',
+      id: `tool_${Date.now()}_${message.parts.length}`,
+      name: toolName,
+      args,
+      result: null,
+      startedAt: Date.now(),
+      endedAt: null,
+      durationMs: 0
+    };
+    message.parts.push(part);
+    this.stats.totalToolCalls++;
+    return part;
+  }
+
+  finalizeToolPart(message, toolId, result) {
+    const part = message.parts.find(p => p.id === toolId || (p.type === 'tool' && !p.endedAt));
+    if (part) {
+      part.result = result;
+      part.endedAt = Date.now();
+      part.durationMs = part.endedAt - part.startedAt;
+    }
+    return part;
+  }
+
+  addTextPart(message, textChunk) {
+    let part = message.parts.find(p => p.type === 'text');
+    if (!part) {
+      part = {
+        type: 'text',
+        content: ''
+      };
+      message.parts.push(part);
+    }
+    part.content += textChunk;
+    return part;
+  }
+
+  async saveToDisk() {
+    try {
+      await fs.mkdir(SESSION_DIR, { recursive: true });
+      const sessionData = {
+        id: this.id,
+        createdAt: this.createdAt,
+        thinkingMode: this.thinkingMode,
+        messages: this.messages,
+        stats: this.stats
+      };
+      await fs.writeFile(SESSION_FILE, JSON.stringify(sessionData, null, 2), 'utf-8');
+      return true;
+    } catch (error) {
+      console.error('Failed to save session:', error);
+      return false;
+    }
+  }
+
+  clear() {
+    this.messages = [];
+    this.stats.totalQueries = 0;
+    this.stats.totalToolCalls = 0;
+    this.stats.totalDurationMs = 0;
+  }
+
+  toSnapshot() {
+    return {
+      id: this.id,
+      createdAt: this.createdAt,
+      thinkingMode: this.thinkingMode,
+      messages: this.messages,
+      stats: { ...this.stats }
+    };
+  }
+
+  reset() {
+    this.id = `sess_${Date.now()}_${Math.random().toString(36).slice(2, 7)}`;
+    this.createdAt = new Date();
+    this.messages = [];
+    this.stats = {
+      totalQueries: 0,
+      totalToolCalls: 0,
+      totalDurationMs: 0
+    };
+  }
+
+  async loadFromDisk() {
+    try {
+      const data = await fs.readFile(SESSION_FILE, 'utf-8');
+      const sessionData = JSON.parse(data);
+      
+      this.id = sessionData.id;
+      this.createdAt = new Date(sessionData.createdAt);
+      this.thinkingMode = sessionData.thinkingMode || 'hide';
+      this.messages = sessionData.messages || [];
+      this.stats = sessionData.stats || {
+        totalQueries: 0,
+        totalToolCalls: 0,
+        totalDurationMs: 0
+      };
+      return true;
+    } catch (error) {
+     
+      return false;
+    }
+  }
+
+  async clearDisk() {
+    try {
+      await fs.unlink(SESSION_FILE);
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  async exportToMarkdown() {
+    const exportDir = path.resolve(process.cwd(), 'exports');
+    try {
+      await fs.mkdir(exportDir, { recursive: true });
+    } catch {}
+
+    const now = new Date();
+    const timestamp = now.toISOString().replace(/[:.]/g, '-').slice(0, 19);
+    const filename = `kiku-session-${timestamp}.md`;
+    const filePath = path.join(exportDir, filename);
+
+    let md = `# Kiku AI Agent - Session Transcript\n\n`;
+    md += `**Session ID:** \`${this.id}\`\n`;
+    md += `**Date:** ${now.toISOString().replace('T', ' ').slice(0, 19)} UTC\n`;
+    md += `**Total Queries:** ${this.stats.totalQueries} | **Tool Invocations:** ${this.stats.totalToolCalls}\n\n---\n\n`;
+
+    for (const msg of this.messages) {
+      if (msg.role === 'user') {
+        const textPart = msg.parts.find(p => p.type === 'text');
+        md += `## User\n${textPart?.content || ''}\n\n`;
+      } else if (msg.role === 'assistant') {
+        md += `## Kiku AI\n\n`;
+        for (const part of msg.parts) {
+          if (part.type === 'reasoning' && part.content) {
+            md += `<details><summary>Reasoning Process (${part.durationMs ? (part.durationMs/1000).toFixed(1) + 's' : 'Complete'})</summary>\n\n\`\`\`\n${part.content.trim()}\n\`\`\`\n</details>\n\n`;
+          } else if (part.type === 'tool') {
+            md += `> >> **Tool Execution: \`${part.name}\`** (${part.durationMs}ms)\n`;
+            md += `> - Arguments: \`${JSON.stringify(part.args)}\`\n`;
+            md += `> - Status: \`${part.result?.status || 'success'}\`\n\n`;
+          } else if (part.type === 'text') {
+            md += `${part.content}\n\n`;
+          }
+        }
+        md += `---\n\n`;
+      }
+    }
+
+    await fs.writeFile(filePath, md, 'utf-8');
+    return { filePath, filename };
+  }
+}

package/server/agent/theme.js

@@ -0,0 +1,124 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+const THEME_STATE_DIR = path.resolve(process.cwd(), '.kiku_sessions');
+const THEME_STATE_FILE = path.join(THEME_STATE_DIR, 'theme.json');
+
+export const THEMES = Object.freeze({
+  sakura: Object.freeze({
+    label: 'Sakura',
+    description: 'Pink accents with neutral gray surfaces',
+    colors: Object.freeze({
+      primary: '255;110;180', secondary: '255;165;195', highlight: '255;215;80',
+      warning: '245;158;11', info: '56;210;255', success: '50;235;130',
+      tertiary: '180;140;255', muted: '130;140;160', subdued: '80;85;95',
+      text: '255;241;247', error: '255;82;115', panel: '45;48;54', panelHeader: '72;52;65',
+    }),
+  }),
+  midnight: Object.freeze({
+    label: 'Midnight',
+    description: 'Deep blue surfaces with cool accents',
+    colors: Object.freeze({
+      primary: '96;165;250', secondary: '125;211;252', highlight: '250;204;21',
+      warning: '251;191;36', info: '34;211;238', success: '74;222;128',
+      tertiary: '167;139;250', muted: '148;163;184', subdued: '71;85;105',
+      text: '219;234;254', error: '251;113;133', panel: '15;23;42', panelHeader: '30;41;69',
+    }),
+  }),
+  ocean: Object.freeze({
+    label: 'Ocean',
+    description: 'Cyan and blue accents on marine-gray surfaces',
+    colors: Object.freeze({
+      primary: '34;211;238', secondary: '103;232;249', highlight: '253;224;71',
+      warning: '251;191;36', info: '56;189;248', success: '45;212;191',
+      tertiary: '96;165;250', muted: '148;163;184', subdued: '71;85;105',
+      text: '207;250;254', error: '251;113;133', panel: '8;47;59', panelHeader: '14;74;89',
+    }),
+  }),
+  forest: Object.freeze({
+    label: 'Forest',
+    description: 'Green and teal accents on natural dark surfaces',
+    colors: Object.freeze({
+      primary: '74;222;128', secondary: '110;231;183', highlight: '250;204;21',
+      warning: '251;191;36', info: '45;212;191', success: '134;239;172',
+      tertiary: '163;230;53', muted: '148;163;153', subdued: '71;85;79',
+      text: '220;252;231', error: '252;129;129', panel: '20;45;34', panelHeader: '30;64;46',
+    }),
+  }),
+  sunset: Object.freeze({
+    label: 'Sunset',
+    description: 'Warm orange accents on charcoal-brown surfaces',
+    colors: Object.freeze({
+      primary: '251;146;60', secondary: '253;186;116', highlight: '250;204;21',
+      warning: '251;191;36', info: '56;189;248', success: '74;222;128',
+      tertiary: '244;114;182', muted: '168;151;143', subdued: '87;72;64',
+      text: '255;237;213', error: '253;106;106', panel: '61;35;28', panelHeader: '87;48;38',
+    }),
+  }),
+  monochrome: Object.freeze({
+    label: 'Monochrome',
+    description: 'Low-distraction grayscale presentation',
+    colors: Object.freeze({
+      primary: '229;231;235', secondary: '209;213;219', highlight: '255;255;255',
+      warning: '209;213;219', info: '229;231;235', success: '229;231;235',
+      tertiary: '209;213;219', muted: '156;163;175', subdued: '107;114;128',
+      text: '245;245;245', error: '212;212;212', panel: '31;31;31', panelHeader: '64;64;64',
+    }),
+  }),
+});
+
+export const THEME_NAMES = Object.freeze(Object.keys(THEMES));
+
+function loadSavedTheme() {
+  const envTheme = process.env.KIKU_THEME?.toLowerCase();
+  if (envTheme && THEMES[envTheme]) return envTheme;
+  try {
+    const saved = JSON.parse(fs.readFileSync(THEME_STATE_FILE, 'utf8'));
+    if (typeof saved.theme === 'string' && THEMES[saved.theme]) return saved.theme;
+  } catch {}
+  return 'sakura';
+}
+
+let activeThemeName = loadSavedTheme();
+
+export function getThemeName() {
+  return activeThemeName;
+}
+
+export function getTheme(name = activeThemeName) {
+  return THEMES[name] || THEMES.sakura;
+}
+
+export function getThemePalette(name = activeThemeName) {
+  return getTheme(name).colors;
+}
+
+export function setTheme(name, { persist = true } = {}) {
+  const normalized = String(name || '').toLowerCase();
+  if (!THEMES[normalized]) return null;
+  activeThemeName = normalized;
+  process.env.KIKU_THEME = normalized;
+
+  if (persist) {
+    fs.mkdirSync(THEME_STATE_DIR, { recursive: true });
+    fs.writeFileSync(THEME_STATE_FILE, JSON.stringify({ theme: normalized }, null, 2) + '\n', 'utf8');
+  }
+  return getTheme(normalized);
+}
+
+export function ansiForeground(rgb) {
+  return `\x1b[38;2;${rgb}m`;
+}
+
+export function ansiBackground(rgb) {
+  return `\x1b[48;2;${rgb}m`;
+}
+
+export function inkColor(rgb) {
+  return `rgb(${rgb.replaceAll(';', ',')})`;
+}
+
+export function getInkPalette(name = activeThemeName) {
+  const palette = getThemePalette(name);
+  return Object.fromEntries(Object.entries(palette).map(([key, value]) => [key, inkColor(value)]));
+}