udsy19
diff --git a/‎nemoclaw/src/blueprint/private-networks.test.ts‎
Lines changed: 16 additions & 0 deletions b/‎nemoclaw/src/blueprint/private-networks.test.ts‎
Lines changed: 16 additions & 0 deletions
diff --git a/‎nemoclaw/src/blueprint/private-networks.ts‎
Lines changed: 36 additions & 123 deletions b/‎nemoclaw/src/blueprint/private-networks.ts‎
Lines changed: 36 additions & 123 deletions
diff --git a/‎nemoclaw/src/shared/private-networks-boundary.cts‎
Lines changed: 131 additions & 0 deletions b/‎nemoclaw/src/shared/private-networks-boundary.cts‎
Lines changed: 131 additions & 0 deletions
diff --git a/‎nemoclaw/tsconfig.shared.json‎
Lines changed: 1 addition & 0 deletions b/‎nemoclaw/tsconfig.shared.json‎
Lines changed: 1 addition & 0 deletions
diff --git a/‎nemoclaw/vitest.project.ts‎
Lines changed: 8 additions & 0 deletions b/‎nemoclaw/vitest.project.ts‎
Lines changed: 8 additions & 0 deletions
@@ -275,6 +275,22 @@ describe("private-networks loader", () => {
       expect(() => getNetworkEntries()).toThrow(/missing or empty 'name'/);
     });
 
+    it.each([" localhost", "localhost ", "."])("rejects non-canonical name %j", (name) => {
+      seedYaml(
+        "/blueprint/private-networks.yaml",
+        `ipv4: []\nipv6: []\nnames:\n  - name: ${JSON.stringify(name)}\n    purpose: malformed\n`,
+      );
+      expect(() => getNetworkEntries()).toThrow(/'name' must be canonical/);
+    });
+
+    it("accepts a canonical name with a terminal dot", () => {
+      seedYaml(
+        "/blueprint/private-networks.yaml",
+        "ipv4: []\nipv6: []\nnames:\n  - name: localhost.\n    purpose: canonical FQDN\n",
+      );
+      expect(isPrivateHostname("localhost")).toBe(true);
+    });
+
     it("rejects a names entry with empty purpose", () => {
       seedYaml(
         "/blueprint/private-networks.yaml",
 
@@ -4,9 +4,8 @@
 // Private-network block list for SSRF validation. Loads the canonical
 // CIDR set from nemoclaw-blueprint/private-networks.yaml and builds a
 // node:net BlockList on first use, then memoises until the YAML file
-// source or stats (mtime/size) change. The CLI has an equivalent module
-// at src/lib/private-networks.ts; the parity test at test/ssrf-parity.test.ts
-// verifies both produce identical results.
+// source or stats (mtime/size) change. Pure parsing and matching live in
+// the shared private-network boundary.
 //
 // Path resolution mirrors loadBlueprint() in runner.ts: honour
 // NEMOCLAW_BLUEPRINT_PATH when set, otherwise try the dev-checkout
@@ -16,37 +15,37 @@
 // cwd-located blueprint is required at runtime.
 
 import { existsSync, readFileSync, statSync } from "node:fs";
-import { BlockList, isIP } from "node:net";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 
-import YAML from "yaml";
-
-export interface NetworkEntry {
-  address: string;
-  prefix: number;
-  purpose: string;
-}
-
-export interface NameEntry {
-  name: string;
-  purpose: string;
-}
-
-export interface NetworkDocument {
-  ipv4: NetworkEntry[];
-  ipv6: NetworkEntry[];
-  names: NameEntry[];
-}
+import * as importedPrivateNetworkBoundary from "../shared/private-networks-boundary.cjs";
+import type {
+  NetworkDocument,
+  PrivateNetworkMatcher,
+} from "../shared/private-networks-boundary.cjs";
+
+export type {
+  NameEntry,
+  NetworkDocument,
+  NetworkEntry,
+} from "../shared/private-networks-boundary.cjs";
+
+// The generated module exposes named CommonJS exports. Source-mode tsx maps
+// the .cjs specifier to .cts and exposes the same module as its default.
+const sourceOrGeneratedPrivateNetworkBoundary =
+  importedPrivateNetworkBoundary as typeof importedPrivateNetworkBoundary & {
+    default?: typeof importedPrivateNetworkBoundary;
+  };
+const { createPrivateNetworkMatcher, parsePrivateNetworkDocument } =
+  sourceOrGeneratedPrivateNetworkBoundary.default ?? sourceOrGeneratedPrivateNetworkBoundary;
 
 interface LoadedNetworks {
   source: string;
   mtimeMs: number;
   size: number;
   checkedAtMs: number;
   networks: NetworkDocument;
-  blockList: BlockList;
-  normalisedNames: string[];
+  matcher: PrivateNetworkMatcher;
 }
 
 // Keep hot SSRF checks in memory while still letting long-running plugin
@@ -74,79 +73,6 @@ function resolveBlueprintPath(): string {
   return ".";
 }
 
-function validateNetworkEntry(
-  entry: unknown,
-  family: "ipv4" | "ipv6",
-  index: number,
-  source: string,
-): NetworkEntry {
-  const where = `${source}: ${family}[${String(index)}]`;
-  if (typeof entry !== "object" || entry === null) {
-    throw new Error(`${where}: expected an object`);
-  }
-  const record = entry as Record<string, unknown>;
-  const address = record.address;
-  const prefix = record.prefix;
-  const purpose = record.purpose;
-  if (typeof address !== "string" || address.length === 0) {
-    throw new Error(`${where}: missing or empty 'address'`);
-  }
-  const expectedFamily = family === "ipv4" ? 4 : 6;
-  if (isIP(address) !== expectedFamily) {
-    throw new Error(
-      `${where}: 'address' must be a valid ${family} literal, got ${JSON.stringify(address)}`,
-    );
-  }
-  const maxPrefix = family === "ipv4" ? 32 : 128;
-  if (typeof prefix !== "number" || !Number.isInteger(prefix) || prefix < 0 || prefix > maxPrefix) {
-    throw new Error(
-      `${where}: 'prefix' must be an integer in [0, ${String(maxPrefix)}], got ${JSON.stringify(prefix)}`,
-    );
-  }
-  if (typeof purpose !== "string" || purpose.trim().length === 0) {
-    throw new Error(
-      `${where}: 'purpose' must be a non-empty string so reviewers can judge the block`,
-    );
-  }
-  return { address, prefix, purpose };
-}
-
-function validateNameEntry(entry: unknown, index: number, source: string): NameEntry {
-  const where = `${source}: names[${String(index)}]`;
-  if (typeof entry !== "object" || entry === null) {
-    throw new Error(`${where}: expected an object`);
-  }
-  const record = entry as Record<string, unknown>;
-  const name = record.name;
-  const purpose = record.purpose;
-  if (typeof name !== "string" || name.length === 0) {
-    throw new Error(`${where}: missing or empty 'name'`);
-  }
-  if (typeof purpose !== "string" || purpose.trim().length === 0) {
-    throw new Error(
-      `${where}: 'purpose' must be a non-empty string so reviewers can judge the block`,
-    );
-  }
-  return { name, purpose };
-}
-
-function parseDocument(raw: string, source: string): NetworkDocument {
-  const parsed = YAML.parse(raw) as Record<string, unknown> | null;
-  if (
-    !parsed ||
-    !Array.isArray(parsed.ipv4) ||
-    !Array.isArray(parsed.ipv6) ||
-    !Array.isArray(parsed.names)
-  ) {
-    throw new Error(`${source}: expected top-level 'ipv4', 'ipv6', and 'names' arrays`);
-  }
-  return {
-    ipv4: parsed.ipv4.map((entry, i) => validateNetworkEntry(entry, "ipv4", i, source)),
-    ipv6: parsed.ipv6.map((entry, i) => validateNetworkEntry(entry, "ipv6", i, source)),
-    names: parsed.names.map((entry, i) => validateNameEntry(entry, i, source)),
-  };
-}
-
 function isNodeEnoent(err: unknown): boolean {
   return err instanceof Error && "code" in err && err.code === "ENOENT";
 }
@@ -179,23 +105,20 @@ function load(): LoadedNetworks {
     cached.checkedAtMs = now;
     return cached;
   }
-  const networks = parseDocument(readPrivateNetworksFile(source), source);
-  const blockList = new BlockList();
-  for (const { address, prefix } of networks.ipv4) blockList.addSubnet(address, prefix, "ipv4");
-  for (const { address, prefix } of networks.ipv6) blockList.addSubnet(address, prefix, "ipv6");
-  const normalisedNames = networks.names.map((e) => e.name.replace(/\.$/, "").toLowerCase());
-  cached = { source, mtimeMs, size, checkedAtMs: now, networks, blockList, normalisedNames };
+  const networks = parsePrivateNetworkDocument(readPrivateNetworksFile(source), source);
+  cached = {
+    source,
+    mtimeMs,
+    size,
+    checkedAtMs: now,
+    networks,
+    matcher: createPrivateNetworkMatcher(networks),
+  };
   return cached;
 }
 
-function isPrivateIpInBlockList(address: string, blockList: BlockList): boolean {
-  const family = isIP(address);
-  if (family === 0) return false;
-  return blockList.check(address, family === 6 ? "ipv6" : "ipv4");
-}
-
-export function getPrivateNetworks(): BlockList {
-  return load().blockList;
+export function getPrivateNetworks(): PrivateNetworkMatcher["blockList"] {
+  return load().matcher.blockList;
 }
 
 export function getNetworkEntries(): NetworkDocument {
@@ -223,7 +146,7 @@ export function resetCache(): void {
  * because BlockList does not extract embedded IPv4 from those forms.
  */
 export function isPrivateIp(address: string): boolean {
-  return isPrivateIpInBlockList(address, getPrivateNetworks());
+  return load().matcher.isPrivateIp(address);
 }
 
 /**
@@ -239,15 +162,5 @@ export function isPrivateIp(address: string): boolean {
  * the narrower isPrivateIp.
  */
 export function isPrivateHostname(hostname: string): boolean {
-  // Strip URL IPv6 brackets before any check. Brackets are only legal
-  // in URL syntax around IPv6 literals, so stripping them is safe for
-  // both the name-level and IP-literal checks below.
-  const stripped =
-    hostname.startsWith("[") && hostname.endsWith("]") ? hostname.slice(1, -1) : hostname;
-  const normalised = stripped.replace(/\.$/, "").toLowerCase();
-  const { blockList, normalisedNames } = load();
-  for (const reserved of normalisedNames) {
-    if (normalised === reserved || normalised.endsWith(`.${reserved}`)) return true;
-  }
-  return isPrivateIpInBlockList(normalised, blockList);
+  return load().matcher.isPrivateHostname(hostname);
 }
@@ -0,0 +1,131 @@
+// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { BlockList, isIP } from "node:net";
+
+import YAML from "yaml";
+
+export interface NetworkEntry {
+  address: string;
+  prefix: number;
+  purpose: string;
+}
+
+export interface NameEntry {
+  name: string;
+  purpose: string;
+}
+
+export interface NetworkDocument {
+  ipv4: NetworkEntry[];
+  ipv6: NetworkEntry[];
+  names: NameEntry[];
+}
+
+export interface PrivateNetworkMatcher {
+  blockList: BlockList;
+  isPrivateIp(address: string): boolean;
+  isPrivateHostname(hostname: string): boolean;
+}
+
+function validateNetworkEntry(
+  entry: unknown,
+  family: "ipv4" | "ipv6",
+  index: number,
+  source: string,
+): NetworkEntry {
+  const where = `${source}: ${family}[${String(index)}]`;
+  if (typeof entry !== "object" || entry === null) {
+    throw new Error(`${where}: expected an object`);
+  }
+  const record = entry as Record<string, unknown>;
+  const { address, prefix, purpose } = record;
+  if (typeof address !== "string" || address.length === 0) {
+    throw new Error(`${where}: missing or empty 'address'`);
+  }
+  const expectedFamily = family === "ipv4" ? 4 : 6;
+  if (isIP(address) !== expectedFamily) {
+    throw new Error(
+      `${where}: 'address' must be a valid ${family} literal, got ${JSON.stringify(address)}`,
+    );
+  }
+  const maxPrefix = family === "ipv4" ? 32 : 128;
+  if (typeof prefix !== "number" || !Number.isInteger(prefix) || prefix < 0 || prefix > maxPrefix) {
+    throw new Error(
+      `${where}: 'prefix' must be an integer in [0, ${String(maxPrefix)}], got ${JSON.stringify(prefix)}`,
+    );
+  }
+  if (typeof purpose !== "string" || purpose.trim().length === 0) {
+    throw new Error(
+      `${where}: 'purpose' must be a non-empty string so reviewers can judge the block`,
+    );
+  }
+  return { address, prefix, purpose };
+}
+
+function validateNameEntry(entry: unknown, index: number, source: string): NameEntry {
+  const where = `${source}: names[${String(index)}]`;
+  if (typeof entry !== "object" || entry === null) {
+    throw new Error(`${where}: expected an object`);
+  }
+  const record = entry as Record<string, unknown>;
+  const { name, purpose } = record;
+  if (typeof name !== "string" || name.length === 0) {
+    throw new Error(`${where}: missing or empty 'name'`);
+  }
+  if (name !== name.trim() || name.replace(/\.$/, "").length === 0) {
+    throw new Error(`${where}: 'name' must be canonical and contain no surrounding whitespace`);
+  }
+  if (typeof purpose !== "string" || purpose.trim().length === 0) {
+    throw new Error(
+      `${where}: 'purpose' must be a non-empty string so reviewers can judge the block`,
+    );
+  }
+  return { name, purpose };
+}
+
+export function parsePrivateNetworkDocument(raw: string, source: string): NetworkDocument {
+  const parsed = YAML.parse(raw) as Record<string, unknown> | null;
+  if (
+    !parsed ||
+    !Array.isArray(parsed.ipv4) ||
+    !Array.isArray(parsed.ipv6) ||
+    !Array.isArray(parsed.names)
+  ) {
+    throw new Error(`${source}: expected top-level 'ipv4', 'ipv6', and 'names' arrays`);
+  }
+  return {
+    ipv4: parsed.ipv4.map((entry, index) => validateNetworkEntry(entry, "ipv4", index, source)),
+    ipv6: parsed.ipv6.map((entry, index) => validateNetworkEntry(entry, "ipv6", index, source)),
+    names: parsed.names.map((entry, index) => validateNameEntry(entry, index, source)),
+  };
+}
+
+export function createPrivateNetworkMatcher(networks: NetworkDocument): PrivateNetworkMatcher {
+  const blockList = new BlockList();
+  for (const { address, prefix } of networks.ipv4) blockList.addSubnet(address, prefix, "ipv4");
+  for (const { address, prefix } of networks.ipv6) blockList.addSubnet(address, prefix, "ipv6");
+  const normalisedNames = networks.names.map((entry) =>
+    entry.name.replace(/\.$/, "").toLowerCase(),
+  );
+
+  const isPrivateIp = (address: string): boolean => {
+    const family = isIP(address);
+    if (family === 0) return false;
+    return blockList.check(address, family === 6 ? "ipv6" : "ipv4");
+  };
+
+  return {
+    blockList,
+    isPrivateIp,
+    isPrivateHostname(hostname: string): boolean {
+      const stripped =
+        hostname.startsWith("[") && hostname.endsWith("]") ? hostname.slice(1, -1) : hostname;
+      const normalised = stripped.replace(/\.$/, "").toLowerCase();
+      for (const reserved of normalisedNames) {
+        if (normalised === reserved || normalised.endsWith(`.${reserved}`)) return true;
+      }
+      return isPrivateIp(normalised);
+    },
+  };
+}
@@ -8,6 +8,7 @@
     "src/shared/banner-boundary.cts",
     "src/shared/credential-filter-boundary.cts",
     "src/shared/openshell-policy-boundary.cts",
+    "src/shared/private-networks-boundary.cts",
     "src/shared/sandbox-name.cts",
     "src/shared/snapshot-sanitizer-boundary.cts"
   ],
 
@@ -13,6 +13,10 @@ const canonicalOpenShellPolicyBoundary = path.resolve(
   import.meta.dirname,
   "src/shared/openshell-policy-boundary.cts",
 );
+const canonicalPrivateNetworksBoundary = path.resolve(
+  import.meta.dirname,
+  "src/shared/private-networks-boundary.cts",
+);
 const canonicalSandboxName = path.resolve(import.meta.dirname, "src/shared/sandbox-name.cts");
 const canonicalSnapshotSanitizerBoundary = path.resolve(
   import.meta.dirname,
@@ -60,6 +64,10 @@ const pluginVitestProjectOptions = {
         find: /^.*openshell-policy-boundary\.cjs$/,
         replacement: canonicalOpenShellPolicyBoundary,
       },
+      {
+        find: /^.*private-networks-boundary\.cjs$/,
+        replacement: canonicalPrivateNetworksBoundary,
+      },
       {
         find: /^.*sandbox-name\.cjs$/,
         replacement: canonicalSandboxName,