kiku-agent 1.0.11 → 1.2.0

package/server/agent/research.js

@@ -1,6 +1,7 @@
 import { ResearchSubagent } from './subagent.js';
 import { executeTool } from './tools.js';
 import { eventBus, Events } from './eventBus.js';
+import { mapConcurrent } from './suggestions.js';
 
 const CATALOG_TOOLS = Object.freeze([
   'global_search', 'get_profile_and_fandom', 'search_works', 'get_work_detail',
@@ -78,13 +79,30 @@ export class ResearchOrchestrator {
   cancel() {
     if (!this.active) return false;
     this.active.controller.abort();
+    this.active = null;
     return true;
   }
 
   async run(question, options = {}) {
     const query = String(question || '').trim();
     if (!query) throw new Error('A research question is required.');
-    if (this.active) throw new Error('A research job is already running.');
+
+
+    if (this.active && this.active.question === query && this.active.promise) {
+      try {
+        return await this.active.promise;
+      } catch (err) {
+    
+      }
+    }
+
+  
+    if (this.active) {
+      try {
+        this.active.controller.abort();
+      } catch {}
+      this.active = null;
+    }
 
     const controller = new AbortController();
     const abortParent = () => controller.abort(options.signal?.reason);
@@ -96,6 +114,7 @@ export class ResearchOrchestrator {
       startedAt: new Date().toISOString(),
       controller,
       workers: new Map(plan.map(task => [task.id, { id: task.id, label: task.label, state: 'pending', toolCalls: 0 }])),
+      promise: null,
     };
     const sharedToolCache = new Map();
     const cachedExecute = async (name, args) => {
@@ -113,90 +132,113 @@ export class ResearchOrchestrator {
       steps: plan.map(p => ({ id: p.id, label: p.label, state: 'pending', objective: p.objective }))
     });
 
-    try {
-      const settled = await Promise.allSettled(plan.map(async task => {
-        const status = job.workers.get(task.id);
-        status.state = 'running';
-        options.onProgress?.({ type: 'worker-start', id: task.id, label: task.label });
-        eventBus.emit(Events.AGENT_PLAN_STEP_UPDATE, {
-          planId: job.id,
-          stepId: task.id,
-          state: 'running',
-          label: task.label,
+    const isLocalProvider = Boolean(
+      this.client?.provider === 'lmstudio' ||
+      this.client?.provider === 'ollama' ||
+      this.client?.isLocal ||
+      this.client?.getProviderInfo?.()?.isLocal
+    );
+    const concurrency = isLocalProvider ? 1 : Math.min(this.maxWorkers, plan.length);
+
+    const executeJob = async () => {
+      try {
+        const settled = await mapConcurrent(plan, concurrency, async task => {
+          const status = job.workers.get(task.id);
+          status.state = 'running';
+          options.onProgress?.({ type: 'worker-start', id: task.id, label: task.label });
+          eventBus.emit(Events.AGENT_PLAN_STEP_UPDATE, {
+            planId: job.id,
+            stepId: task.id,
+            state: 'running',
+            label: task.label,
+          });
+
+          const worker = new ResearchSubagent({
+            client: this.client,
+            executeTool: cachedExecute,
+            allowedTools: task.tools,
+            maxIterations: this.maxIterations,
+          });
+          const result = await worker.run(task.objective, {
+            signal: controller.signal,
+            skillContext: options.skillContext,
+            onProgress: event => {
+              if (event.type === 'tool') status.toolCalls += 1;
+              options.onProgress?.({ ...event, workerId: task.id, label: task.label });
+            },
+          });
+          status.state = 'complete';
+          options.onProgress?.({ type: 'worker-complete', id: task.id, label: task.label });
+          eventBus.emit(Events.AGENT_PLAN_STEP_UPDATE, {
+            planId: job.id,
+            stepId: task.id,
+            state: 'complete',
+            label: task.label,
+          });
+          return { id: task.id, label: task.label, ...result };
         });
 
-        const worker = new ResearchSubagent({
-          client: this.client,
-          executeTool: cachedExecute,
-          allowedTools: task.tools,
-          maxIterations: this.maxIterations,
+        const reports = settled.map((entry, index) => {
+          if (entry.status === 'fulfilled') return entry.value;
+          const task = plan[index];
+          const status = job.workers.get(task.id);
+          status.state = controller.signal.aborted ? 'cancelled' : 'failed';
+          status.error = entry.reason?.message || 'Unknown worker error';
+          return { id: task.id, label: task.label, answer: '', error: status.error, toolCalls: [] };
         });
-        const result = await worker.run(task.objective, {
+        if (controller.signal.aborted) throw controller.signal.reason || new DOMException('Aborted', 'AbortError');
+
+        const usable = reports.filter(report => report.answer);
+        if (usable.length === 0) {
+          const { webExtract } = await import('./webSearch.js');
+          const fallbackRes = await webExtract(query);
+          if (fallbackRes?.text) {
+            usable.push({ label: 'Live Web Intelligence', answer: fallbackRes.text, sources: fallbackRes.sources || [] });
+          } else {
+            throw new Error('All research workers failed and no web intelligence was returned.');
+          }
+        }
+        const synthesisPrompt = options.mode === 'verify'
+          ? 'Return a clear verdict: VERIFIED, UNVERIFIED, CONFLICTING, or FALSE. Explain briefly and cite only URLs present in the reports.'
+          : 'Synthesize a comprehensive, detailed, and polished answer with verified facts. Cite only URLs present in the reports.';
+        const synthesis = await this.client.chat({
+          messages: [
+            { role: 'system', content: `You are the Kiku research editor. ${synthesisPrompt} Never invent a source, date, title, or URL. Match the language of the question. Do not reveal hidden reasoning.` },
+            { role: 'user', content: JSON.stringify({ question: query, reports: usable.map(({ label, answer }) => ({ label, answer })) }) },
+          ],
+          temperature: 0.1,
+          stream: false,
           signal: controller.signal,
-          skillContext: options.skillContext,
-          onProgress: event => {
-            if (event.type === 'tool') status.toolCalls += 1;
-            options.onProgress?.({ ...event, workerId: task.id, label: task.label });
-          },
         });
-        status.state = 'complete';
-        options.onProgress?.({ type: 'worker-complete', id: task.id, label: task.label });
-        eventBus.emit(Events.AGENT_PLAN_STEP_UPDATE, {
+        const answer = synthesis?.content || usable.map(report => `### ${report.label}\n${report.answer}`).join('\n\n');
+        const sources = uniqueUrls(usable.map(report => report.answer).join('\n'));
+        const result = {
+          id: job.id,
+          mode: options.mode || 'research',
+          question: query,
+          answer,
+          sources,
+          reports,
+          startedAt: job.startedAt,
+          completedAt: new Date().toISOString(),
+        };
+        this.lastResult = result;
+        options.onProgress?.({ type: 'complete', id: job.id, sources: sources.length });
+        eventBus.emit(Events.AGENT_PLAN_COMPLETE, {
           planId: job.id,
-          stepId: task.id,
-          state: 'complete',
-          label: task.label,
+          sourcesCount: sources.length,
+          reportsCount: reports.length,
         });
-        return { id: task.id, label: task.label, ...result };
-      }));
-
-      const reports = settled.map((entry, index) => {
-        if (entry.status === 'fulfilled') return entry.value;
-        const task = plan[index];
-        const status = job.workers.get(task.id);
-        status.state = controller.signal.aborted ? 'cancelled' : 'failed';
-        status.error = entry.reason?.message || 'Unknown worker error';
-        return { id: task.id, label: task.label, answer: '', error: status.error, toolCalls: [] };
-      });
-      if (controller.signal.aborted) throw controller.signal.reason || new DOMException('Aborted', 'AbortError');
-
-      const usable = reports.filter(report => report.answer);
-      if (usable.length === 0) throw new Error('All research workers failed.');
-      const synthesisPrompt = options.mode === 'verify'
-        ? 'Return a clear verdict: VERIFIED, UNVERIFIED, CONFLICTING, or FALSE. Explain briefly and cite only URLs present in the reports.'
-        : 'Synthesize a direct, polished answer. Separate verified facts, conflicts, and missing evidence. Cite only URLs present in the reports.';
-      const synthesis = await this.client.chat({
-        messages: [
-          { role: 'system', content: `You are the Kiku research editor. ${synthesisPrompt} Never invent a source, date, title, or URL. Match the language of the question. Do not reveal hidden reasoning.` },
-          { role: 'user', content: JSON.stringify({ question: query, reports: usable.map(({ label, answer }) => ({ label, answer })) }) },
-        ],
-        temperature: 0.1,
-        stream: false,
-        signal: controller.signal,
-      });
-      const answer = synthesis?.content || usable.map(report => `### ${report.label}\n${report.answer}`).join('\n\n');
-      const sources = uniqueUrls(usable.map(report => report.answer).join('\n'));
-      const result = {
-        id: job.id,
-        mode: options.mode || 'research',
-        question: query,
-        answer,
-        sources,
-        reports,
-        startedAt: job.startedAt,
-        completedAt: new Date().toISOString(),
-      };
-      this.lastResult = result;
-      options.onProgress?.({ type: 'complete', id: job.id, sources: sources.length });
-      eventBus.emit(Events.AGENT_PLAN_COMPLETE, {
-        planId: job.id,
-        sourcesCount: sources.length,
-        reportsCount: reports.length,
-      });
-      return result;
-    } finally {
-      options.signal?.removeEventListener('abort', abortParent);
-      this.active = null;
-    }
+        return result;
+      } finally {
+        options.signal?.removeEventListener('abort', abortParent);
+        if (this.active?.id === job.id) {
+          this.active = null;
+        }
+      }
+    };
+
+    job.promise = executeJob();
+    return job.promise;
   }
 }

package/server/agent/sanitizer.js

@@ -1,6 +1,5 @@
 import path from 'node:path';
-
-
+import { lookup as dnsLookup } from 'node:dns/promises';
 
 const MAX_QUERY_LENGTH = 32768;
 const MAX_PATH_LENGTH = 2048;
@@ -66,10 +65,24 @@ const BLOCKED_HOST_PATTERNS = [
 const DANGEROUS_EXTENSIONS = new Set([
   '.sh', '.bash', '.zsh', '.ps1', '.cmd', '.bat', '.exe', '.msi',
   '.com', '.scr', '.pif', '.vbs', '.vbe', '.js', '.jse', '.wsf',
-  '.wsh', '.reg',
+  '.wsh', '.reg', '.pem', '.key', '.p12', '.pfx', '.der',
 ]);
 
 
+const SENSITIVE_FILENAMES = [
+  /(^|[\\/])\.env(\.|$)/i,
+  /(^|[\\/])cookies\.txt$/i,
+  /(^|[\\/])\.(git|npmrc|netrc|ssh)([\\/]|$)/i,
+  /(^|[\\/])\.kiku_sessions([\\/]|$)/i,
+  /\.pem$/i,
+  /\.key$/i,
+  /\.p12$/i,
+  /\.pfx$/i,
+  /secret/i,
+  /credential/i,
+];
+
+
 export function stripAnsi(str) {
   if (typeof str !== 'string') return '';
   return str.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '')
@@ -138,6 +151,12 @@ export function sanitizeFilePath(filePath, projectRoot = process.cwd(), { blockD
     return { safe: false, resolvedPath: resolved, reason: 'Path escapes project root (traversal detected)' };
   }
 
+  for (const pattern of SENSITIVE_FILENAMES) {
+    if (pattern.test(resolved)) {
+      return { safe: false, resolvedPath: resolved, reason: 'Sensitive file path blocked (secrets/dotfiles)' };
+    }
+  }
+
   if (blockDangerousExtensions) {
     const normalizedPath = resolved.replace(/[ .]+$/g, '');
     const extension = path.extname(normalizedPath).toLowerCase();
@@ -150,6 +169,40 @@ export function sanitizeFilePath(filePath, projectRoot = process.cwd(), { blockD
 }
 
 
+function isPrivateIPv4(ip) {
+  const parts = ip.split('.').map(Number);
+  if (parts.length !== 4) return false;
+  const [a, b] = parts;
+  if (a === 10) return true;
+  if (a === 127) return true;
+  if (a === 0) return true;
+  if (a === 169 && b === 254) return true;
+  if (a === 172 && b >= 16 && b <= 31) return true;
+  if (a === 192 && b === 168) return true;
+  if (a === 100 && b >= 64 && b <= 127) return true;
+  if (a === 198 && (b === 18 || b === 19)) return true;
+  if (a >= 224) return true;
+  return false;
+}
+
+function isPrivateIPv6(ip) {
+  const normalized = ip.toLowerCase();
+  if (normalized === '::' || normalized === '::1') return true;
+  if (normalized.startsWith('fc') || normalized.startsWith('fd')) return true;
+  if (normalized.startsWith('fe80') || normalized.startsWith('fe8') || normalized.startsWith('fe9') || normalized.startsWith('fea') || normalized.startsWith('feb')) return true;
+  if (normalized.startsWith('::ffff:')) {
+    const v4 = normalized.slice(7);
+    return isPrivateIPv4(v4);
+  }
+  if (normalized.startsWith('2001:db8:')) return true;
+  if (normalized.startsWith('::')) return true;
+  return false;
+}
+
+function isIpAddress(hostname) {
+  return /^\d+\.\d+\.\d+\.\d+$/.test(hostname) || /^[0-9a-f:]+$/i.test(hostname);
+}
+
 export function sanitizeUrl(urlStr) {
   if (typeof urlStr !== 'string' || !urlStr.trim()) {
     return { safe: false, reason: 'URL is empty or not a string' };
@@ -173,6 +226,10 @@ export function sanitizeUrl(urlStr) {
     return { safe: false, reason: `Unsafe protocol: ${url.protocol} (only http/https allowed)` };
   }
 
+  if (url.username || url.password) {
+    return { safe: false, reason: 'Credentials embedded in URLs are not allowed' };
+  }
+
   
   const hostname = url.hostname.replace(/^\[|\]$/g, '').replace(/\.$/, '').toLowerCase();
   for (const pattern of BLOCKED_HOST_PATTERNS) {
@@ -181,7 +238,36 @@ export function sanitizeUrl(urlStr) {
     }
   }
 
-  return { safe: true, url };
+  if (!isIpAddress(hostname)) {
+    url.__pendingDnsCheck = true;
+  }
+
+  return { safe: true, url, hostname };
+}
+
+
+export async function assertSafeUrlHostname(hostname) {
+  if (!hostname || typeof hostname !== 'string') return { safe: false, reason: 'Missing hostname' };
+  const clean = hostname.replace(/^\[|\]$/g, '').replace(/\.$/, '').toLowerCase();
+
+  if (isIpAddress(clean)) {
+    if (isPrivateIPv4(clean) || isPrivateIPv6(clean)) {
+      return { safe: false, reason: `Resolved host is private/internal: ${clean}` };
+    }
+    return { safe: true };
+  }
+
+  try {
+    const addresses = await dnsLookup(clean, { all: true });
+    for (const { address } of addresses) {
+      if (isPrivateIPv4(address) || isPrivateIPv6(address)) {
+        return { safe: false, reason: `Host resolved to private/internal IP: ${address}` };
+      }
+    }
+    return { safe: true };
+  } catch {
+    return { safe: false, reason: 'Unable to resolve hostname for SSRF check' };
+  }
 }
 
 
@@ -244,7 +330,7 @@ export function sanitizeToolArgs(toolName, args) {
     }
 
     case 'fetch_api': {
-    
+     
       const endpoint = sanitized.endpoint;
       if (endpoint && typeof endpoint === 'string') {
         const clean = stripAnsi(endpoint).trim();
@@ -253,6 +339,14 @@ export function sanitizeToolArgs(toolName, args) {
         }
         sanitized.endpoint = clean;
       }
+
+      const baseUrl = sanitized.baseUrl;
+      if (baseUrl) {
+        const check = sanitizeUrl(baseUrl);
+        if (!check.safe) {
+          return { safe: false, sanitized: {}, warnings: [`API base URL rejected: ${check.reason}`] };
+        }
+      }
       break;
     }
 
@@ -290,18 +384,15 @@ export function sanitizeResponse(response) {
 
   
   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,
+    /system\s*prompt\s*[:=]/gi,
+    /you\s*are\s*(actually|really)\s+(a|an)\s+/gi,
+    /my\s*instructions\s*(are|say|tell)/gi,
+    /i\s*was\s*(told|instructed|programmed)\s+to/gi,
   ];
 
   let sanitized = response;
   for (const pattern of leakPatterns) {
-    if (pattern.test(sanitized)) {
-     
-      break;
-    }
+    sanitized = sanitized.replace(pattern, '[system content]');
   }
 
   return sanitized;