fix: correct knowledge cache keying by URL and fix SSRF private IP ranges

- knowledge.ts: cache was keyed globally (single null check), so a second
  call with a different URL would silently return the first URL's data.
  Changed to a Map<url, chunks> so each URL is cached independently.
- fetch.ts: SSRF block checked hostname.startsWith('172.') which blocks
  all 172.x addresses. Corrected to RFC1918 range 172.16–31.x.x.
  Also added 169.254.x.x (link-local / cloud metadata endpoint).

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01JKGMRpgihA4io2frodqLjt

Author: dzianisv

packages/backend/src/routes/fetch.ts

@@ -14,6 +14,24 @@ const fetchSchema = z.object({
   body: z.any().optional(),
 });
 
+function isPrivateHostname(hostname: string): boolean {
+  // Loopback
+  if (['localhost', '127.0.0.1', '0.0.0.0', '::1'].includes(hostname)) return true;
+  // Link-local / cloud metadata (169.254.x.x)
+  if (hostname.startsWith('169.254.')) return true;
+  // RFC1918 class A (10.x.x.x)
+  if (hostname.startsWith('10.')) return true;
+  // RFC1918 class B (172.16.x.x – 172.31.x.x)
+  const parts = hostname.split('.');
+  if (parts[0] === '172' && parts.length >= 2) {
+    const second = parseInt(parts[1], 10);
+    if (second >= 16 && second <= 31) return true;
+  }
+  // RFC1918 class C (192.168.x.x)
+  if (hostname.startsWith('192.168.')) return true;
+  return false;
+}
+
 fetchRoute.post('/', async (c) => {
   const parsed = fetchSchema.safeParse(await c.req.json());
   if (!parsed.success) {
@@ -26,8 +44,7 @@ fetchRoute.post('/', async (c) => {
   try {
     const urlObj = new URL(url);
     const hostname = urlObj.hostname;
-    if (['localhost', '127.0.0.1', '0.0.0.0', '::1'].includes(hostname) ||
-        hostname.startsWith('10.') || hostname.startsWith('192.168.') || hostname.startsWith('172.')) {
+    if (isPrivateHostname(hostname)) {
       return c.json({ error: 'Internal URLs are not allowed' }, 403);
     }
   } catch {
@@ -51,10 +68,10 @@ fetchRoute.post('/', async (c) => {
     // Read response as text (safe for JSON and text content types)
     const text = await response.text();
     if (text.length > MAX_RESPONSE_SIZE) {
-      return c.json({ 
-        error: 'Response too large', 
+      return c.json({
+        error: 'Response too large',
         truncated: text.slice(0, MAX_RESPONSE_SIZE),
-        maxSize: MAX_RESPONSE_SIZE 
+        maxSize: MAX_RESPONSE_SIZE
       }, 413);
     }
 

packages/widget/src/agent/knowledge.ts

@@ -7,16 +7,18 @@ interface KnowledgeChunk {
   metadata?: Record<string, any>;
 }
 
-let knowledgeCache: KnowledgeChunk[] | null = null;
+const knowledgeCache = new Map<string, KnowledgeChunk[]>();
 
 export async function loadKnowledge(url: string): Promise<KnowledgeChunk[]> {
-  if (knowledgeCache) return knowledgeCache;
-  
+  const cached = knowledgeCache.get(url);
+  if (cached) return cached;
+
   try {
     const res = await fetch(url);
     if (!res.ok) throw new Error(`Failed to load KB: ${res.status}`);
-    knowledgeCache = await res.json();
-    return knowledgeCache!;
+    const chunks: KnowledgeChunk[] = await res.json();
+    knowledgeCache.set(url, chunks);
+    return chunks;
   } catch (err) {
     console.warn('Failed to load knowledge base:', err);
     return [];
@@ -77,6 +79,10 @@ function tokenize(text: string): string[] {
     .filter(t => t.length > 2);
 }
 
-export function clearKnowledgeCache() {
-  knowledgeCache = null;
+export function clearKnowledgeCache(url?: string) {
+  if (url) {
+    knowledgeCache.delete(url);
+  } else {
+    knowledgeCache.clear();
+  }
 }