miladyai 2.0.0-alpha.27

package/dist/security/audit-log.js

@@ -0,0 +1,149 @@
+//#region src/security/audit-log.ts
+/**
+* Append-only audit log for sandbox security events.
+* Never log real secret values — only token IDs and metadata.
+*/
+const AUDIT_EVENT_TYPES = [
+	"sandbox_mode_transition",
+	"secret_token_replacement_outbound",
+	"secret_sanitization_inbound",
+	"privileged_capability_invocation",
+	"policy_decision",
+	"signing_request_submitted",
+	"signing_request_rejected",
+	"signing_request_approved",
+	"plugin_fallback_attempt",
+	"security_kill_switch",
+	"sandbox_lifecycle",
+	"fetch_proxy_error"
+];
+const AUDIT_SEVERITIES = [
+	"info",
+	"warn",
+	"error",
+	"critical"
+];
+const DEFAULT_MAX_ENTRIES = 5e3;
+const PROCESS_FEED_MAX_ENTRIES = DEFAULT_MAX_ENTRIES;
+const processFeedEntries = [];
+const processFeedSubscribers = /* @__PURE__ */ new Set();
+function trimEntries(entries, maxEntries) {
+	if (entries.length <= maxEntries) return;
+	const keep = Math.floor(maxEntries / 2);
+	if (keep <= 0) {
+		entries.length = 0;
+		return;
+	}
+	entries.splice(0, entries.length - keep);
+}
+function publishToProcessFeed(entry) {
+	processFeedEntries.push(entry);
+	trimEntries(processFeedEntries, PROCESS_FEED_MAX_ENTRIES);
+	for (const subscriber of processFeedSubscribers) try {
+		subscriber(entry);
+	} catch {}
+}
+function toSinceTimestamp(sinceMs) {
+	if (sinceMs === void 0) return void 0;
+	if (!Number.isFinite(sinceMs)) return void 0;
+	return Math.trunc(sinceMs);
+}
+function toBoundedLimit(limit) {
+	if (limit === void 0) return void 0;
+	if (!Number.isFinite(limit)) return void 0;
+	return Math.max(1, Math.trunc(limit));
+}
+function queryAuditFeed(query = {}) {
+	const sinceTimestamp = toSinceTimestamp(query.sinceMs);
+	const boundedLimit = toBoundedLimit(query.limit);
+	let entries = processFeedEntries;
+	if (query.type) entries = entries.filter((entry) => entry.type === query.type);
+	if (query.severity) entries = entries.filter((entry) => entry.severity === query.severity);
+	if (sinceTimestamp !== void 0) entries = entries.filter((entry) => Date.parse(entry.timestamp) >= sinceTimestamp);
+	if (boundedLimit !== void 0) return entries.slice(-boundedLimit);
+	return [...entries];
+}
+function getAuditFeedSize() {
+	return processFeedEntries.length;
+}
+function subscribeAuditFeed(subscriber) {
+	processFeedSubscribers.add(subscriber);
+	return () => {
+		processFeedSubscribers.delete(subscriber);
+	};
+}
+var SandboxAuditLog = class {
+	constructor(config = {}) {
+		this.entries = [];
+		this.consoleEnabled = config.console ?? true;
+		this.maxEntries = config.maxEntries ?? DEFAULT_MAX_ENTRIES;
+		this.sink = config.sink;
+	}
+	record(entry) {
+		const full = {
+			...entry,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		this.entries.push(full);
+		publishToProcessFeed(full);
+		trimEntries(this.entries, this.maxEntries);
+		if (this.consoleEnabled) {
+			const line = `[AUDIT:${full.severity.toUpperCase()}] ${full.type}: ${full.summary}`;
+			if (full.severity === "critical" || full.severity === "error") console.error(line);
+			else if (full.severity === "warn") console.warn(line);
+			else console.log(line);
+		}
+		this.sink?.(full);
+	}
+	recordTokenReplacement(direction, url, tokenIds) {
+		this.record({
+			type: direction === "outbound" ? "secret_token_replacement_outbound" : "secret_sanitization_inbound",
+			summary: `${direction}: ${tokenIds.length} token(s) for ${url}`,
+			metadata: {
+				direction,
+				url,
+				tokenCount: tokenIds.length,
+				tokenIds: tokenIds.join(",")
+			},
+			severity: "info"
+		});
+	}
+	recordCapabilityInvocation(capability, detail, metadata) {
+		this.record({
+			type: "privileged_capability_invocation",
+			summary: `${capability}: ${detail}`,
+			metadata: {
+				capability,
+				...metadata
+			},
+			severity: "info"
+		});
+	}
+	recordPolicyDecision(decision, reason, metadata) {
+		this.record({
+			type: "policy_decision",
+			summary: `${decision}: ${reason}`,
+			metadata: {
+				decision,
+				reason,
+				...metadata
+			},
+			severity: decision === "deny" ? "warn" : "info"
+		});
+	}
+	getRecent(count = 100) {
+		return this.entries.slice(-count);
+	}
+	getByType(type, count = 50) {
+		return this.entries.filter((e) => e.type === type).slice(-count);
+	}
+	get size() {
+		return this.entries.length;
+	}
+	clear() {
+		this.entries = [];
+	}
+};
+
+//#endregion
+export { AUDIT_EVENT_TYPES, AUDIT_SEVERITIES, SandboxAuditLog, getAuditFeedSize, queryAuditFeed, subscribeAuditFeed };

package/dist/security/network-policy.js

@@ -0,0 +1,70 @@
+import net from "node:net";
+
+//#region src/security/network-policy.ts
+const ALWAYS_BLOCKED_IP_PATTERNS = [
+	/^0\./,
+	/^169\.254\./,
+	/^fe[89ab][0-9a-f]:/i,
+	/^::$/i,
+	/^::1$/i
+];
+const PRIVATE_IP_PATTERNS = [
+	/^10\./,
+	/^127\./,
+	/^172\.(1[6-9]|2\d|3[01])\./,
+	/^192\.168\./,
+	/^f[cd][0-9a-f]{2}:/i
+];
+function normalizeHostLike(value) {
+	return value.trim().toLowerCase().replace(/^\[|\]$/g, "");
+}
+function decodeIpv6MappedHex(mapped) {
+	const parts = mapped.split(":");
+	if (parts.length < 1 || parts.length > 2) return null;
+	const parsed = parts.map((part) => {
+		if (!/^[0-9a-f]{1,4}$/i.test(part)) return NaN;
+		return Number.parseInt(part, 16);
+	});
+	if (parsed.some((value) => !Number.isFinite(value))) return null;
+	const [hi, lo] = parsed.length === 1 ? [0, parsed[0]] : parsed;
+	return [
+		hi >> 8,
+		hi & 255,
+		lo >> 8,
+		lo & 255
+	].join(".");
+}
+function canonicalizeIpv6(ip) {
+	try {
+		return new URL(`http://[${ip}]/`).hostname.replace(/^\[|\]$/g, "");
+	} catch {
+		return null;
+	}
+}
+function normalizeIpForPolicy(ip) {
+	const base = normalizeHostLike(ip).split("%")[0];
+	if (!base) return base;
+	let normalized = base;
+	if (net.isIP(normalized) === 6) normalized = canonicalizeIpv6(normalized) ?? normalized;
+	let mapped = null;
+	if (normalized.startsWith("::ffff:")) mapped = normalized.slice(7);
+	else if (normalized.startsWith("0:0:0:0:0:ffff:")) mapped = normalized.slice(15);
+	if (!mapped) return normalized;
+	if (net.isIP(mapped) === 4) return mapped;
+	return decodeIpv6MappedHex(mapped) ?? normalized;
+}
+function isBlockedPrivateOrLinkLocalIp(ip) {
+	const normalized = normalizeIpForPolicy(ip);
+	if (ALWAYS_BLOCKED_IP_PATTERNS.some((pattern) => pattern.test(normalized))) return true;
+	return PRIVATE_IP_PATTERNS.some((pattern) => pattern.test(normalized));
+}
+function isLoopbackHost(host) {
+	const normalized = normalizeIpForPolicy(host);
+	if (!normalized) return false;
+	if (normalized === "localhost" || normalized === "::1") return true;
+	if (net.isIP(normalized) === 4) return normalized.startsWith("127.");
+	return false;
+}
+
+//#endregion
+export { isBlockedPrivateOrLinkLocalIp, isLoopbackHost, normalizeHostLike, normalizeIpForPolicy };