neoagent 3.2.1-beta.2 → 3.2.1-beta.3

package/server/utils/cloud-security.js

@@ -1,5 +1,28 @@
 'use strict';
 
+const dns = require('node:dns');
+const net = require('node:net');
+
+const ALLOWED_SCHEMES = new Set(['http', 'https']);
+const BLOCKED_ANDROID_INTENT_SCHEMES = new Set([
+  'about',
+  'chrome',
+  'chrome-extension',
+  'content',
+  'data',
+  'file',
+  'javascript',
+  'vbscript',
+]);
+
+function urlAbortError(signal) {
+  if (signal?.reason instanceof Error) return signal.reason;
+  const error = new Error('URL validation was aborted.');
+  error.name = 'AbortError';
+  error.code = 'ABORT_ERR';
+  return error;
+}
+
 // URL schemes that must never be navigated to in the cloud browser or Android.
 const BLOCKED_SCHEMES = new Set([
   'javascript',
@@ -56,8 +79,26 @@ function isPrivateHost(hostname) {
 
   // IPv6 loopback, link-local and unique-local
   if (h === '::1' || h === '::') return true;
-  if (h.startsWith('fe80:')) return true;
+  if (/^fe[89ab][0-9a-f]:/.test(h)) return true; // fe80::/10 link-local
+  if (/^fe[c-f][0-9a-f]:/.test(h)) return true; // fec0::/10 deprecated site-local
   if (/^f[cd][0-9a-f]*:/.test(h)) return true; // fc00::/7 unique-local
+  if (h.startsWith('ff')) return true; // IPv6 multicast
+  if (h === '100::' || h.startsWith('100::')) return true; // discard-only prefix
+  if (h === '2001:db8::' || h.startsWith('2001:db8:')) return true; // documentation
+
+  if (net.isIPv4(h)) {
+    const [a, b, c] = h.split('.').map(Number);
+    if (a === 0 || a === 10 || a === 127 || a >= 224) return true;
+    if (a === 100 && b >= 64 && b <= 127) 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 === 192 && b === 0 && c === 0) return true;
+    if (a === 192 && b === 0 && c === 2) return true;
+    if (a === 198 && (b === 18 || b === 19)) return true;
+    if (a === 198 && b === 51 && c === 100) return true;
+    if (a === 203 && b === 0 && c === 113) return true;
+  }
 
   for (const pattern of PRIVATE_IPV4) {
     if (pattern.test(h)) return true;
@@ -90,7 +131,7 @@ function validateCloudUrl(urlString) {
   }
 
   const scheme = parsed.protocol.replace(/:$/, '').toLowerCase();
-  if (BLOCKED_SCHEMES.has(scheme)) return { allowed: false };
+  if (BLOCKED_SCHEMES.has(scheme) || !ALLOWED_SCHEMES.has(scheme)) return { allowed: false };
 
   const hostname = parsed.hostname;
   if (isPrivateHost(hostname)) return { allowed: false };
@@ -99,4 +140,70 @@ function validateCloudUrl(urlString) {
   return { allowed: true };
 }
 
-module.exports = { validateCloudUrl, isPrivateHost };
+async function validateCloudUrlWithDns(urlString, options = {}) {
+  if (options.signal?.aborted) {
+    throw urlAbortError(options.signal);
+  }
+  const syntactic = validateCloudUrl(urlString);
+  if (!syntactic.allowed) return syntactic;
+
+  const hostname = new URL(urlString).hostname.replace(/^\[|\]$/g, '');
+  if (net.isIP(hostname)) return { allowed: !isPrivateHost(hostname) };
+
+  const lookup = options.lookup || dns.promises.lookup;
+  const timeoutMs = Math.max(100, Math.min(Number(options.timeoutMs) || 5000, 30_000));
+  let timer = null;
+  let onAbort = null;
+  try {
+    const pending = [
+      lookup(hostname, { all: true, verbatim: true }),
+      new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error('DNS lookup timed out.')), timeoutMs);
+      }),
+    ];
+    if (options.signal) {
+      pending.push(new Promise((_, reject) => {
+        onAbort = () => {
+          reject(urlAbortError(options.signal));
+        };
+        options.signal.addEventListener('abort', onAbort, { once: true });
+      }));
+    }
+    const addresses = await Promise.race(pending);
+    const resolved = Array.isArray(addresses) ? addresses : [addresses];
+    if (resolved.length === 0) return { allowed: false };
+    if (resolved.some((entry) => isPrivateHost(entry?.address || entry))) {
+      return { allowed: false };
+    }
+    return { allowed: true };
+  } catch (error) {
+    if (options.signal?.aborted) throw error;
+    return { allowed: false };
+  } finally {
+    if (timer) clearTimeout(timer);
+    if (onAbort) options.signal?.removeEventListener('abort', onAbort);
+  }
+}
+
+async function validateAndroidIntentUrl(urlString, options = {}) {
+  if (!urlString || typeof urlString !== 'string') return { allowed: false };
+  let parsed;
+  try {
+    parsed = new URL(urlString);
+  } catch {
+    return { allowed: false };
+  }
+  const scheme = parsed.protocol.replace(/:$/, '').toLowerCase();
+  if (BLOCKED_ANDROID_INTENT_SCHEMES.has(scheme)) return { allowed: false };
+  if (ALLOWED_SCHEMES.has(scheme)) {
+    return validateCloudUrlWithDns(urlString, options);
+  }
+  return { allowed: /^[a-z][a-z0-9+.-]*$/.test(scheme) };
+}
+
+module.exports = {
+  validateAndroidIntentUrl,
+  validateCloudUrl,
+  validateCloudUrlWithDns,
+  isPrivateHost,
+};

package/server/utils/files.js

@@ -0,0 +1,31 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { randomUUID } = require('node:crypto');
+const { createAbortError, throwIfAborted } = require('./abort');
+
+async function writeBufferAtomic(destination, data, options = {}) {
+  const target = String(destination || '').trim();
+  if (!target) throw new Error('Atomic file destination is required.');
+  const resolved = path.resolve(target);
+  const temporary = `${resolved}.${process.pid}.${randomUUID()}.tmp`;
+  throwIfAborted(options.signal, 'File write was aborted.');
+  try {
+    await fs.promises.writeFile(temporary, data, {
+      flag: 'wx',
+      mode: options.mode ?? 0o600,
+      signal: options.signal,
+    });
+    throwIfAborted(options.signal, 'File write was aborted.');
+    await fs.promises.rename(temporary, resolved);
+    return resolved;
+  } catch (error) {
+    if (options.signal?.aborted) throw createAbortError(options.signal, 'File write was aborted.');
+    throw error;
+  } finally {
+    await fs.promises.rm(temporary, { force: true }).catch(() => {});
+  }
+}
+
+module.exports = { writeBufferAtomic };

package/server/utils/image_payload.js

@@ -0,0 +1,95 @@
+'use strict';
+
+const MAX_SCREENSHOT_BYTES = 20 * 1024 * 1024;
+const PNG_SIGNATURE = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+
+function imageError(message, code = 'INVALID_IMAGE_PAYLOAD') {
+  const error = new Error(message);
+  error.code = code;
+  return error;
+}
+
+function detectImage(buffer) {
+  if (
+    buffer.length >= 24
+    && buffer.subarray(0, PNG_SIGNATURE.length).equals(PNG_SIGNATURE)
+    && buffer.subarray(12, 16).toString('ascii') === 'IHDR'
+  ) {
+    const width = buffer.readUInt32BE(16);
+    const height = buffer.readUInt32BE(20);
+    if (!width || !height || width > 32768 || height > 32768 || width * height > 150_000_000) {
+      throw imageError('Screenshot PNG has invalid or unsafe dimensions.');
+    }
+    return { contentType: 'image/png', extension: 'png', width, height };
+  }
+  if (
+    buffer.length >= 4
+    && buffer[0] === 0xff
+    && buffer[1] === 0xd8
+    && buffer[buffer.length - 2] === 0xff
+    && buffer[buffer.length - 1] === 0xd9
+  ) {
+    return { contentType: 'image/jpeg', extension: 'jpg', width: null, height: null };
+  }
+  throw imageError('Screenshot payload is not a valid PNG or JPEG image.');
+}
+
+function validateImageBuffer(value, options = {}) {
+  const buffer = Buffer.isBuffer(value) ? value : Buffer.from(value || []);
+  const maxBytes = Math.max(1024, Number(options.maxBytes) || MAX_SCREENSHOT_BYTES);
+  if (!buffer.length) throw imageError('Screenshot payload is empty.');
+  if (buffer.length > maxBytes) {
+    throw imageError(
+      `Screenshot payload exceeds the ${maxBytes}-byte limit.`,
+      'IMAGE_PAYLOAD_TOO_LARGE',
+    );
+  }
+  const detected = detectImage(buffer);
+  const allowedTypes = Array.isArray(options.allowedTypes) && options.allowedTypes.length
+    ? new Set(options.allowedTypes.map((type) => String(type).toLowerCase()))
+    : null;
+  if (allowedTypes && !allowedTypes.has(detected.contentType)) {
+    throw imageError(`Screenshot type ${detected.contentType} is not allowed.`);
+  }
+  return { buffer, ...detected };
+}
+
+function decodeBase64Image(value, options = {}) {
+  const text = String(value || '');
+  if (!text) throw imageError('Screenshot payload is empty.');
+  let declaredType = null;
+  let encoded = text;
+  if (text.startsWith('data:')) {
+    const match = text.match(/^data:image\/(png|jpeg|jpg);base64,([A-Za-z0-9+/]*={0,2})$/i);
+    if (!match) throw imageError('Screenshot data URL is malformed or uses an unsupported type.');
+    declaredType = match[1].toLowerCase() === 'png' ? 'image/png' : 'image/jpeg';
+    encoded = match[2];
+  }
+  if (!encoded || encoded.length % 4 === 1 || !/^[A-Za-z0-9+/]*={0,2}$/.test(encoded)) {
+    throw imageError('Screenshot base64 payload is malformed.');
+  }
+  const maxBytes = Math.max(1024, Number(options.maxBytes) || MAX_SCREENSHOT_BYTES);
+  const padding = encoded.endsWith('==') ? 2 : (encoded.endsWith('=') ? 1 : 0);
+  const estimatedBytes = Math.floor(encoded.length * 3 / 4) - padding;
+  if (estimatedBytes > maxBytes) {
+    throw imageError(
+      `Screenshot payload exceeds the ${maxBytes}-byte limit.`,
+      'IMAGE_PAYLOAD_TOO_LARGE',
+    );
+  }
+  const buffer = Buffer.from(encoded, 'base64');
+  if (buffer.toString('base64').replace(/=+$/, '') !== encoded.replace(/=+$/, '')) {
+    throw imageError('Screenshot base64 payload is malformed.');
+  }
+  const validated = validateImageBuffer(buffer, { ...options, maxBytes });
+  if (declaredType && declaredType !== validated.contentType) {
+    throw imageError('Screenshot data URL type does not match its image bytes.');
+  }
+  return validated;
+}
+
+module.exports = {
+  MAX_SCREENSHOT_BYTES,
+  decodeBase64Image,
+  validateImageBuffer,
+};

package/server/utils/retry.js

@@ -0,0 +1,107 @@
+'use strict';
+
+const { createAbortError, isAbortError } = require('./abort');
+
+const RETRYABLE_HTTP_STATUS = new Set([
+  408, 409, 425, 429, 500, 502, 503, 504, 520, 521, 522, 524, 529,
+]);
+const RETRYABLE_NETWORK_CODES = new Set([
+  'ECONNRESET',
+  'ECONNREFUSED',
+  'ETIMEDOUT',
+  'EPIPE',
+  'EAI_AGAIN',
+  'ENOTFOUND',
+  'ENETUNREACH',
+  'EHOSTUNREACH',
+  'EAGAIN',
+  'UND_ERR_CONNECT_TIMEOUT',
+  'UND_ERR_SOCKET',
+  'UND_ERR_HEADERS_TIMEOUT',
+  'INTEGRATION_HTTP_TIMEOUT',
+]);
+
+function getHttpStatus(error) {
+  if (!error || typeof error !== 'object') return null;
+  const candidates = [
+    error.status,
+    error.statusCode,
+    error.response?.status,
+    error.cause?.status,
+  ];
+  for (const value of candidates) {
+    const status = Number(value);
+    if (Number.isFinite(status) && status >= 100 && status < 600) return status;
+  }
+  return null;
+}
+
+function getErrorCode(error) {
+  if (!error || typeof error !== 'object') return null;
+  return error.code || error.errno || error.cause?.code || null;
+}
+
+function readHeader(headers, name) {
+  if (!headers) return undefined;
+  if (typeof headers.get === 'function') return headers.get(name);
+  return headers[name] ?? headers[name.toLowerCase()];
+}
+
+function retryAfterMilliseconds(headers, now = Date.now()) {
+  const milliseconds = readHeader(headers, 'retry-after-ms');
+  if (milliseconds !== undefined && milliseconds !== null && String(milliseconds).trim()) {
+    const parsed = Number(milliseconds);
+    if (Number.isFinite(parsed) && parsed >= 0) return parsed;
+  }
+
+  const retryAfter = readHeader(headers, 'retry-after');
+  if (retryAfter === undefined || retryAfter === null || !String(retryAfter).trim()) {
+    return null;
+  }
+  const seconds = Number(retryAfter);
+  if (Number.isFinite(seconds) && seconds >= 0) return seconds * 1000;
+  const date = Date.parse(String(retryAfter));
+  return Number.isFinite(date) ? Math.max(0, date - now) : null;
+}
+
+function computeBackoffMs(attempt, baseDelayMs, maxDelayMs) {
+  const exp = Math.min(maxDelayMs, baseDelayMs * 2 ** (attempt - 1));
+  return Math.round(exp / 2 + Math.random() * (exp / 2));
+}
+
+function isTransientIoError(error) {
+  if (!error || isAbortError(error)) return false;
+  const status = getHttpStatus(error);
+  if (status !== null) return RETRYABLE_HTTP_STATUS.has(status);
+  const code = getErrorCode(error);
+  return Boolean(code && RETRYABLE_NETWORK_CODES.has(String(code)));
+}
+
+function abortableDelay(milliseconds, signal = null) {
+  if (signal?.aborted) return Promise.reject(createAbortError(signal));
+  return new Promise((resolve, reject) => {
+    let timer = null;
+    const onAbort = () => {
+      if (timer) clearTimeout(timer);
+      signal?.removeEventListener('abort', onAbort);
+      reject(createAbortError(signal));
+    };
+    timer = setTimeout(() => {
+      signal?.removeEventListener('abort', onAbort);
+      resolve();
+    }, Math.max(0, Number(milliseconds) || 0));
+    signal?.addEventListener('abort', onAbort, { once: true });
+  });
+}
+
+module.exports = {
+  RETRYABLE_HTTP_STATUS,
+  RETRYABLE_NETWORK_CODES,
+  abortableDelay,
+  computeBackoffMs,
+  getErrorCode,
+  getHttpStatus,
+  isTransientIoError,
+  readHeader,
+  retryAfterMilliseconds,
+};