@causyne/agent 1.10.13 → 1.10.17

package/src/browser/searchProviders.js

@@ -0,0 +1,156 @@
+const MAX_PROVIDER_BYTES = 2 * 1024 * 1024;
+const MAX_RESULTS = 10;
+const SEARCH_TIMEOUT_MS = 15_000;
+function decodeEntities(value) {
+    const named = { amp: '&', apos: "'", gt: '>', lt: '<', nbsp: ' ', quot: '"' };
+    return value.replace(/&(#x[0-9a-f]+|#\d+|[a-z]+);/gi, (full, entity) => {
+        if (entity.startsWith('#x'))
+            return String.fromCodePoint(Number.parseInt(entity.slice(2), 16));
+        if (entity.startsWith('#'))
+            return String.fromCodePoint(Number.parseInt(entity.slice(1), 10));
+        return named[entity.toLowerCase()] ?? full;
+    });
+}
+function cleanMarkup(value) {
+    return decodeEntities(value.replace(/<!\[CDATA\[([\s\S]*?)\]\]>/g, '$1').replace(/<[^>]+>/g, ' '))
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+function publicResultUrl(value) {
+    try {
+        const parsed = new URL(decodeEntities(value));
+        if (!['http:', 'https:'].includes(parsed.protocol))
+            return null;
+        if (/(^|\.)(bing|duckduckgo)\.com$/i.test(parsed.hostname))
+            return null;
+        return parsed.href;
+    }
+    catch {
+        return null;
+    }
+}
+export function parseBingRss(xml) {
+    const results = [];
+    const seen = new Set();
+    for (const item of xml.matchAll(/<item\b[^>]*>([\s\S]*?)<\/item>/gi)) {
+        const body = item[1] ?? '';
+        const title = cleanMarkup(body.match(/<title\b[^>]*>([\s\S]*?)<\/title>/i)?.[1] ?? '');
+        const url = publicResultUrl(cleanMarkup(body.match(/<link\b[^>]*>([\s\S]*?)<\/link>/i)?.[1] ?? ''));
+        const snippet = cleanMarkup(body.match(/<description\b[^>]*>([\s\S]*?)<\/description>/i)?.[1] ?? '');
+        if (!title || !url || seen.has(url))
+            continue;
+        seen.add(url);
+        results.push({ title: title.slice(0, 300), url, snippet: snippet.slice(0, 500), engine: 'bing-rss' });
+        if (results.length >= MAX_RESULTS)
+            break;
+    }
+    return results;
+}
+export function parseDuckDuckGoHtml(html) {
+    const results = [];
+    const seen = new Set();
+    const anchors = [...html.matchAll(/<a\b[^>]*class=["'][^"']*result__a[^"']*["'][^>]*href=["']([^"']+)["'][^>]*>([\s\S]*?)<\/a>/gi)];
+    for (const [index, anchor] of anchors.entries()) {
+        let href = decodeEntities(anchor[1] ?? '');
+        try {
+            const candidate = new URL(href, 'https://html.duckduckgo.com/');
+            if (candidate.hostname.endsWith('duckduckgo.com') && candidate.pathname.startsWith('/l/')) {
+                href = candidate.searchParams.get('uddg') ?? href;
+            }
+        }
+        catch {
+            continue;
+        }
+        const url = publicResultUrl(href);
+        const title = cleanMarkup(anchor[2] ?? '');
+        const tail = html.slice(anchor.index ?? 0, anchors[index + 1]?.index ?? html.length);
+        const snippet = cleanMarkup(tail.match(/class=["'][^"']*result__snippet[^"']*["'][^>]*>([\s\S]*?)<\/(?:a|div)>/i)?.[1] ?? '');
+        if (!title || !url || seen.has(url))
+            continue;
+        seen.add(url);
+        results.push({ title: title.slice(0, 300), url, snippet: snippet.slice(0, 500), engine: 'duckduckgo-html' });
+        if (results.length >= MAX_RESULTS)
+            break;
+    }
+    return results;
+}
+async function readBoundedText(response) {
+    const declared = Number(response.headers.get('content-length') ?? '0');
+    if (Number.isFinite(declared) && declared > MAX_PROVIDER_BYTES)
+        throw new Error('search response is too large');
+    if (!response.body)
+        return '';
+    const reader = response.body.getReader();
+    const chunks = [];
+    let size = 0;
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            size += value.byteLength;
+            if (size > MAX_PROVIDER_BYTES) {
+                await reader.cancel().catch(() => { });
+                throw new Error('search response is too large');
+            }
+            chunks.push(value);
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    return Buffer.concat(chunks.map(chunk => Buffer.from(chunk)), size).toString('utf8');
+}
+export async function searchPublicWeb(query, options = {}) {
+    const cleaned = String(query ?? '').trim();
+    if (!cleaned || cleaned.length > 1_000)
+        throw new Error('Search query must contain 1-1000 characters');
+    const fetchImpl = options.fetchImpl ?? fetch;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), SEARCH_TIMEOUT_MS);
+    const signal = options.signal ?? controller.signal;
+    const providers = [
+        {
+            engine: 'duckduckgo-html',
+            url: `https://html.duckduckgo.com/html/?q=${encodeURIComponent(cleaned)}`,
+            parse: parseDuckDuckGoHtml,
+            accept: 'text/html,application/xhtml+xml'
+        },
+        {
+            engine: 'bing-rss',
+            url: `https://www.bing.com/search?format=rss&q=${encodeURIComponent(cleaned)}`,
+            parse: parseBingRss,
+            accept: 'application/rss+xml,application/xml,text/xml'
+        }
+    ];
+    const failures = [];
+    try {
+        for (const provider of providers) {
+            try {
+                const response = await fetchImpl(provider.url, {
+                    method: 'GET',
+                    redirect: 'error',
+                    signal,
+                    headers: {
+                        Accept: provider.accept,
+                        'Accept-Language': 'en-US,en;q=0.8',
+                        'User-Agent': 'Causyne-Agent/1.10 (+https://causyne.com)'
+                    }
+                });
+                if (!response.ok)
+                    throw new Error(`HTTP ${response.status}`);
+                const results = provider.parse(await readBoundedText(response));
+                if (results.length > 0)
+                    return results;
+                failures.push(`${provider.engine}: no results`);
+            }
+            catch (error) {
+                failures.push(`${provider.engine}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+    throw new Error(`Lightweight search providers exhausted. ${failures.join('; ')}`);
+}

package/src/browser/searchProviders.ts

@@ -0,0 +1,156 @@
+const MAX_PROVIDER_BYTES = 2 * 1024 * 1024;
+const MAX_RESULTS = 10;
+const SEARCH_TIMEOUT_MS = 15_000;
+
+export interface SearchResult {
+  title: string;
+  url: string;
+  snippet: string;
+  engine: string;
+}
+
+interface SearchOptions {
+  fetchImpl?: typeof fetch;
+  signal?: AbortSignal;
+}
+
+function decodeEntities(value: string): string {
+  const named: Record<string, string> = { amp: '&', apos: "'", gt: '>', lt: '<', nbsp: ' ', quot: '"' };
+  return value.replace(/&(#x[0-9a-f]+|#\d+|[a-z]+);/gi, (full, entity: string) => {
+    if (entity.startsWith('#x')) return String.fromCodePoint(Number.parseInt(entity.slice(2), 16));
+    if (entity.startsWith('#')) return String.fromCodePoint(Number.parseInt(entity.slice(1), 10));
+    return named[entity.toLowerCase()] ?? full;
+  });
+}
+
+function cleanMarkup(value: string): string {
+  return decodeEntities(value.replace(/<!\[CDATA\[([\s\S]*?)\]\]>/g, '$1').replace(/<[^>]+>/g, ' '))
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function publicResultUrl(value: string): string | null {
+  try {
+    const parsed = new URL(decodeEntities(value));
+    if (!['http:', 'https:'].includes(parsed.protocol)) return null;
+    if (/(^|\.)(bing|duckduckgo)\.com$/i.test(parsed.hostname)) return null;
+    return parsed.href;
+  } catch {
+    return null;
+  }
+}
+
+export function parseBingRss(xml: string): SearchResult[] {
+  const results: SearchResult[] = [];
+  const seen = new Set<string>();
+  for (const item of xml.matchAll(/<item\b[^>]*>([\s\S]*?)<\/item>/gi)) {
+    const body = item[1] ?? '';
+    const title = cleanMarkup(body.match(/<title\b[^>]*>([\s\S]*?)<\/title>/i)?.[1] ?? '');
+    const url = publicResultUrl(cleanMarkup(body.match(/<link\b[^>]*>([\s\S]*?)<\/link>/i)?.[1] ?? ''));
+    const snippet = cleanMarkup(body.match(/<description\b[^>]*>([\s\S]*?)<\/description>/i)?.[1] ?? '');
+    if (!title || !url || seen.has(url)) continue;
+    seen.add(url);
+    results.push({ title: title.slice(0, 300), url, snippet: snippet.slice(0, 500), engine: 'bing-rss' });
+    if (results.length >= MAX_RESULTS) break;
+  }
+  return results;
+}
+
+export function parseDuckDuckGoHtml(html: string): SearchResult[] {
+  const results: SearchResult[] = [];
+  const seen = new Set<string>();
+  const anchors = [...html.matchAll(/<a\b[^>]*class=["'][^"']*result__a[^"']*["'][^>]*href=["']([^"']+)["'][^>]*>([\s\S]*?)<\/a>/gi)];
+  for (const [index, anchor] of anchors.entries()) {
+    let href = decodeEntities(anchor[1] ?? '');
+    try {
+      const candidate = new URL(href, 'https://html.duckduckgo.com/');
+      if (candidate.hostname.endsWith('duckduckgo.com') && candidate.pathname.startsWith('/l/')) {
+        href = candidate.searchParams.get('uddg') ?? href;
+      }
+    } catch {
+      continue;
+    }
+    const url = publicResultUrl(href);
+    const title = cleanMarkup(anchor[2] ?? '');
+    const tail = html.slice(anchor.index ?? 0, anchors[index + 1]?.index ?? html.length);
+    const snippet = cleanMarkup(tail.match(/class=["'][^"']*result__snippet[^"']*["'][^>]*>([\s\S]*?)<\/(?:a|div)>/i)?.[1] ?? '');
+    if (!title || !url || seen.has(url)) continue;
+    seen.add(url);
+    results.push({ title: title.slice(0, 300), url, snippet: snippet.slice(0, 500), engine: 'duckduckgo-html' });
+    if (results.length >= MAX_RESULTS) break;
+  }
+  return results;
+}
+
+async function readBoundedText(response: Response): Promise<string> {
+  const declared = Number(response.headers.get('content-length') ?? '0');
+  if (Number.isFinite(declared) && declared > MAX_PROVIDER_BYTES) throw new Error('search response is too large');
+  if (!response.body) return '';
+  const reader = response.body.getReader();
+  const chunks: Uint8Array[] = [];
+  let size = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      size += value.byteLength;
+      if (size > MAX_PROVIDER_BYTES) {
+        await reader.cancel().catch(() => {});
+        throw new Error('search response is too large');
+      }
+      chunks.push(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  return Buffer.concat(chunks.map(chunk => Buffer.from(chunk)), size).toString('utf8');
+}
+
+export async function searchPublicWeb(query: string, options: SearchOptions = {}): Promise<SearchResult[]> {
+  const cleaned = String(query ?? '').trim();
+  if (!cleaned || cleaned.length > 1_000) throw new Error('Search query must contain 1-1000 characters');
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), SEARCH_TIMEOUT_MS);
+  const signal = options.signal ?? controller.signal;
+  const providers = [
+    {
+      engine: 'duckduckgo-html',
+      url: `https://html.duckduckgo.com/html/?q=${encodeURIComponent(cleaned)}`,
+      parse: parseDuckDuckGoHtml,
+      accept: 'text/html,application/xhtml+xml'
+    },
+    {
+      engine: 'bing-rss',
+      url: `https://www.bing.com/search?format=rss&q=${encodeURIComponent(cleaned)}`,
+      parse: parseBingRss,
+      accept: 'application/rss+xml,application/xml,text/xml'
+    }
+  ];
+  const failures: string[] = [];
+  try {
+    for (const provider of providers) {
+      try {
+        const response = await fetchImpl(provider.url, {
+          method: 'GET',
+          redirect: 'error',
+          signal,
+          headers: {
+            Accept: provider.accept,
+            'Accept-Language': 'en-US,en;q=0.8',
+            'User-Agent': 'Causyne-Agent/1.10 (+https://causyne.com)'
+          }
+        });
+        if (!response.ok) throw new Error(`HTTP ${response.status}`);
+        const results = provider.parse(await readBoundedText(response));
+        if (results.length > 0) return results;
+        failures.push(`${provider.engine}: no results`);
+      } catch (error) {
+        failures.push(`${provider.engine}: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+  } finally {
+    clearTimeout(timeout);
+  }
+  throw new Error(`Lightweight search providers exhausted. ${failures.join('; ')}`);
+}

package/src/browser/snapshotWindow.js

@@ -0,0 +1,28 @@
+// Adapted from camofox-browser's MIT-licensed snapshot windowing design.
+// Copyright (c) 2025 Jo, Inc. See docs/THIRD_PARTY_NOTICES.md.
+export const MAX_SNAPSHOT_CHARS = 80_000;
+export const SNAPSHOT_TAIL_CHARS = 5_000;
+export function windowSnapshot(snapshot, requestedOffset = 0) {
+    const text = String(snapshot ?? '');
+    const totalChars = text.length;
+    if (totalChars <= MAX_SNAPSHOT_CHARS) {
+        return { text, truncated: false, totalChars, offset: 0, hasMore: false, nextOffset: null };
+    }
+    const contentBudget = MAX_SNAPSHOT_CHARS - SNAPSHOT_TAIL_CHARS - 240;
+    const maximumOffset = Math.max(0, totalChars - SNAPSHOT_TAIL_CHARS);
+    const offset = Math.min(Math.max(0, Math.floor(requestedOffset)), maximumOffset);
+    const chunkEnd = Math.min(offset + contentBudget, maximumOffset);
+    const hasMore = chunkEnd < maximumOffset;
+    const tail = text.slice(-SNAPSHOT_TAIL_CHARS);
+    const marker = hasMore
+        ? `\n[Snapshot truncated at character ${chunkEnd} of ${totalChars}. Request offset ${chunkEnd} for the next window.]\n`
+        : '\n';
+    return {
+        text: text.slice(offset, chunkEnd) + marker + tail,
+        truncated: true,
+        totalChars,
+        offset,
+        hasMore,
+        nextOffset: hasMore ? chunkEnd : null
+    };
+}

package/src/browser/snapshotWindow.ts

@@ -0,0 +1,40 @@
+// Adapted from camofox-browser's MIT-licensed snapshot windowing design.
+// Copyright (c) 2025 Jo, Inc. See docs/THIRD_PARTY_NOTICES.md.
+
+export const MAX_SNAPSHOT_CHARS = 80_000;
+export const SNAPSHOT_TAIL_CHARS = 5_000;
+
+export interface SnapshotWindow {
+  text: string;
+  truncated: boolean;
+  totalChars: number;
+  offset: number;
+  hasMore: boolean;
+  nextOffset: number | null;
+}
+
+export function windowSnapshot(snapshot: string, requestedOffset = 0): SnapshotWindow {
+  const text = String(snapshot ?? '');
+  const totalChars = text.length;
+  if (totalChars <= MAX_SNAPSHOT_CHARS) {
+    return { text, truncated: false, totalChars, offset: 0, hasMore: false, nextOffset: null };
+  }
+
+  const contentBudget = MAX_SNAPSHOT_CHARS - SNAPSHOT_TAIL_CHARS - 240;
+  const maximumOffset = Math.max(0, totalChars - SNAPSHOT_TAIL_CHARS);
+  const offset = Math.min(Math.max(0, Math.floor(requestedOffset)), maximumOffset);
+  const chunkEnd = Math.min(offset + contentBudget, maximumOffset);
+  const hasMore = chunkEnd < maximumOffset;
+  const tail = text.slice(-SNAPSHOT_TAIL_CHARS);
+  const marker = hasMore
+    ? `\n[Snapshot truncated at character ${chunkEnd} of ${totalChars}. Request offset ${chunkEnd} for the next window.]\n`
+    : '\n';
+  return {
+    text: text.slice(offset, chunkEnd) + marker + tail,
+    truncated: true,
+    totalChars,
+    offset,
+    hasMore,
+    nextOffset: hasMore ? chunkEnd : null
+  };
+}

package/src/browser/urlPolicy.js

@@ -0,0 +1,89 @@
+import { lookup } from 'node:dns/promises';
+import { isIP } from 'node:net';
+const DNS_CACHE_MS = 5 * 60_000;
+const hostCache = new Map();
+function isPrivateIpv4(address) {
+    const parts = address.split('.').map(Number);
+    if (parts.length !== 4 || parts.some(part => !Number.isInteger(part) || part < 0 || part > 255))
+        return true;
+    const [a = 0, b = 0, c = 0] = parts;
+    return a === 0
+        || a === 10
+        || a === 127
+        || (a === 169 && b === 254)
+        || (a === 172 && b >= 16 && b <= 31)
+        || (a === 192 && b === 168)
+        || (a === 192 && b === 0 && (c === 0 || c === 2))
+        || (a === 192 && b === 88 && c === 99)
+        || (a === 100 && b >= 64 && b <= 127)
+        || (a === 198 && (b === 18 || b === 19))
+        || (a === 198 && b === 51 && c === 100)
+        || (a === 203 && b === 0 && c === 113)
+        || a >= 224;
+}
+function isPrivateIpv6(address) {
+    const normalized = address.toLowerCase().split('%')[0] ?? '';
+    if (normalized === '::' || normalized === '::1')
+        return true;
+    if (normalized.startsWith('fc') || normalized.startsWith('fd') || normalized.startsWith('fe8')
+        || normalized.startsWith('fe9') || normalized.startsWith('fea') || normalized.startsWith('feb')
+        || normalized.startsWith('fec') || normalized.startsWith('fed') || normalized.startsWith('fee')
+        || normalized.startsWith('fef') || normalized.startsWith('ff') || normalized.startsWith('2001:db8:')
+        || normalized === '2001:db8::' || normalized.startsWith('64:ff9b:'))
+        return true;
+    if (normalized.startsWith('::ffff:')) {
+        const mapped = normalized.slice('::ffff:'.length);
+        return isIP(mapped) === 4 ? isPrivateIpv4(mapped) : true;
+    }
+    return false;
+}
+export function isPrivateAddress(address) {
+    const version = isIP(address);
+    if (version === 4)
+        return isPrivateIpv4(address);
+    if (version === 6)
+        return isPrivateIpv6(address);
+    return true;
+}
+function blockedHostname(hostname) {
+    const host = hostname.toLowerCase().replace(/\.$/, '');
+    return host === 'localhost'
+        || host.endsWith('.localhost')
+        || host.endsWith('.local')
+        || host.endsWith('.internal')
+        || host === 'metadata.google.internal';
+}
+async function resolvedAddresses(hostname) {
+    const cached = hostCache.get(hostname);
+    if (cached && cached.expiresAt > Date.now())
+        return cached.addresses;
+    const results = await lookup(hostname, { all: true, verbatim: true });
+    const addresses = [...new Set(results.map(result => result.address))];
+    hostCache.set(hostname, { expiresAt: Date.now() + DNS_CACHE_MS, addresses });
+    return addresses;
+}
+export async function assertPublicWebUrl(value) {
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        throw new Error('URL must be absolute and valid');
+    }
+    if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+        throw new Error('Only http and https URLs are allowed');
+    }
+    if (url.username || url.password)
+        throw new Error('URLs containing credentials are not allowed');
+    if (blockedHostname(url.hostname))
+        throw new Error('Local and internal hostnames are not allowed');
+    const literalVersion = isIP(url.hostname);
+    const addresses = literalVersion ? [url.hostname] : await resolvedAddresses(url.hostname);
+    if (addresses.length === 0 || addresses.some(isPrivateAddress)) {
+        throw new Error('Local, private, link-local, multicast, and reserved network addresses are not allowed');
+    }
+    return url;
+}
+export function clearUrlPolicyCache() {
+    hostCache.clear();
+}

package/src/browser/urlPolicy.ts

@@ -0,0 +1,89 @@
+import { lookup } from 'node:dns/promises';
+import { isIP } from 'node:net';
+
+const DNS_CACHE_MS = 5 * 60_000;
+const hostCache = new Map<string, { expiresAt: number; addresses: string[] }>();
+
+function isPrivateIpv4(address: string): boolean {
+  const parts = address.split('.').map(Number);
+  if (parts.length !== 4 || parts.some(part => !Number.isInteger(part) || part < 0 || part > 255)) return true;
+  const [a = 0, b = 0, c = 0] = parts;
+  return a === 0
+    || a === 10
+    || a === 127
+    || (a === 169 && b === 254)
+    || (a === 172 && b >= 16 && b <= 31)
+    || (a === 192 && b === 168)
+    || (a === 192 && b === 0 && (c === 0 || c === 2))
+    || (a === 192 && b === 88 && c === 99)
+    || (a === 100 && b >= 64 && b <= 127)
+    || (a === 198 && (b === 18 || b === 19))
+    || (a === 198 && b === 51 && c === 100)
+    || (a === 203 && b === 0 && c === 113)
+    || a >= 224;
+}
+
+function isPrivateIpv6(address: string): boolean {
+  const normalized = address.toLowerCase().split('%')[0] ?? '';
+  if (normalized === '::' || normalized === '::1') return true;
+  if (normalized.startsWith('fc') || normalized.startsWith('fd') || normalized.startsWith('fe8')
+      || normalized.startsWith('fe9') || normalized.startsWith('fea') || normalized.startsWith('feb')
+      || normalized.startsWith('fec') || normalized.startsWith('fed') || normalized.startsWith('fee')
+      || normalized.startsWith('fef') || normalized.startsWith('ff') || normalized.startsWith('2001:db8:')
+      || normalized === '2001:db8::' || normalized.startsWith('64:ff9b:')) return true;
+  if (normalized.startsWith('::ffff:')) {
+    const mapped = normalized.slice('::ffff:'.length);
+    return isIP(mapped) === 4 ? isPrivateIpv4(mapped) : true;
+  }
+  return false;
+}
+
+export function isPrivateAddress(address: string): boolean {
+  const version = isIP(address);
+  if (version === 4) return isPrivateIpv4(address);
+  if (version === 6) return isPrivateIpv6(address);
+  return true;
+}
+
+function blockedHostname(hostname: string): boolean {
+  const host = hostname.toLowerCase().replace(/\.$/, '');
+  return host === 'localhost'
+    || host.endsWith('.localhost')
+    || host.endsWith('.local')
+    || host.endsWith('.internal')
+    || host === 'metadata.google.internal';
+}
+
+async function resolvedAddresses(hostname: string): Promise<string[]> {
+  const cached = hostCache.get(hostname);
+  if (cached && cached.expiresAt > Date.now()) return cached.addresses;
+  const results = await lookup(hostname, { all: true, verbatim: true });
+  const addresses = [...new Set(results.map(result => result.address))];
+  hostCache.set(hostname, { expiresAt: Date.now() + DNS_CACHE_MS, addresses });
+  return addresses;
+}
+
+export async function assertPublicWebUrl(value: string): Promise<URL> {
+  let url: URL;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new Error('URL must be absolute and valid');
+  }
+  if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+    throw new Error('Only http and https URLs are allowed');
+  }
+  if (url.username || url.password) throw new Error('URLs containing credentials are not allowed');
+  if (blockedHostname(url.hostname)) throw new Error('Local and internal hostnames are not allowed');
+
+  const literalVersion = isIP(url.hostname);
+  const addresses = literalVersion ? [url.hostname] : await resolvedAddresses(url.hostname);
+  if (addresses.length === 0 || addresses.some(isPrivateAddress)) {
+    throw new Error('Local, private, link-local, multicast, and reserved network addresses are not allowed');
+  }
+  return url;
+}
+
+export function clearUrlPolicyCache(): void {
+  hostCache.clear();
+}

package/src/checkpoints.js

@@ -7,7 +7,12 @@ import crypto from 'crypto';
 import * as gitBackend from './gitSnapshot.js';
 import { unifiedDiff, looksBinary } from './textDiff.js';
 import { causyneHome } from './utils/paths.js';
-import { getActiveSessionId, SESSION_DIR } from './sessionStore.js';
+import {
+  getActiveSessionId,
+  restoreSessionFromSnapshot,
+  sessionTranscriptFile,
+  SESSION_DIR
+} from './sessionStore.js';
 
 /**
  * Diagnostics, off by default.
@@ -57,7 +62,7 @@ function activeHistoryFile() {
     const id = getActiveSessionId();
     if (id) {
       const safe = String(id).replace(/[^a-zA-Z0-9_-]/g, '');
-      if (safe) return path.join(SESSION_DIR, `${safe}.json`);
+      if (safe) return sessionTranscriptFile(safe);
     }
   } catch (e) { /* fall through to the legacy file */ }
   return HISTORY_FILE;
@@ -890,10 +895,18 @@ export function undoTask(taskId, options = {}) {
           history: { hash: writeObject(buffer), size: buffer.length, file: resolved }
         });
       }
-      assertSafeTarget(resolved);
-      fs.mkdirSync(path.dirname(resolved), { recursive: true });
-      fs.writeFileSync(resolved, readObject(start.history.hash), { mode: 0o600 });
-      historyRestored = true;
+      const snapshot = readObject(start.history.hash);
+      if (path.extname(resolved) === '.jsonl') {
+        historyRestored = restoreSessionFromSnapshot(resolved, snapshot);
+        if (!historyRestored) throw new Error('conversation journal snapshot could not be projected');
+      } else {
+        // Older checkpoints still point at the legacy JSON snapshot. Keep that
+        // recovery path while new sessions remain append-only.
+        assertSafeTarget(resolved);
+        fs.mkdirSync(path.dirname(resolved), { recursive: true });
+        fs.writeFileSync(resolved, snapshot, { mode: 0o600 });
+        historyRestored = true;
+      }
     } catch (e) {
       results.push({ path: target, action: `FAILED: ${e.message}` });
     }