> ## Documentation Index
> Fetch the complete documentation index at: https://docs.endorlabs.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Choose a Package Firewall deployment model
> Compare the two ways to route package installs through Package Firewall and pick the setup that matches your environment.
export const LicenseBadge = ({sku, skus, relation = 'any'}) => {
const DATA_URL = '/snippets/license-sku-data.json';
const CACHE_KEY = 'license-sku-data';
const CACHE_TTL_MS = 60 * 60 * 1000;
const REGISTRY_KEY = '__licenseSkuRegistry';
const FALLBACK_LICENSES_URL = '/introduction/licenses';
const ACCENT = '#26D07C';
const CONJUNCTION = {
any: 'or',
all: 'and'
};
const FONT_STACK = '-apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif';
const [isDark, setIsDark] = useState(false);
const [data, setData] = useState(null);
const [hasFetchError, setHasFetchError] = useState(false);
const skuList = useMemo(() => {
if (Array.isArray(skus) && skus.length > 0) {
return skus.filter(code => typeof code === 'string' && code.trim()).map(c => c.trim());
}
if (typeof sku === 'string' && sku.trim()) {
return [sku.trim()];
}
return [];
}, [sku, skus]);
useEffect(() => {
const check = () => {
const root = document.documentElement;
setIsDark(root.dataset.theme === 'dark' || root.classList.contains('dark'));
};
check();
const observer = new MutationObserver(check);
observer.observe(document.documentElement, {
attributes: true,
attributeFilter: ['data-theme', 'class']
});
return () => observer.disconnect();
}, []);
useEffect(() => {
let cancelled = false;
const readCache = () => {
try {
const raw = sessionStorage.getItem(CACHE_KEY);
if (!raw) return null;
const parsed = JSON.parse(raw);
if (Date.now() - parsed.ts > CACHE_TTL_MS) {
sessionStorage.removeItem(CACHE_KEY);
return null;
}
return parsed.data;
} catch (e) {
return null;
}
};
const writeCache = value => {
try {
sessionStorage.setItem(CACHE_KEY, JSON.stringify({
ts: Date.now(),
data: value
}));
} catch (e) {}
};
const fetchSkuData = async () => {
const cached = readCache();
if (cached) return cached;
if (!globalThis[REGISTRY_KEY]) {
globalThis[REGISTRY_KEY] = {};
}
const registry = globalThis[REGISTRY_KEY];
if (registry[CACHE_KEY]) return registry[CACHE_KEY];
const promise = (async () => {
const resp = await fetch(DATA_URL);
if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
const json = await resp.json();
writeCache(json);
return json;
})();
registry[CACHE_KEY] = promise;
promise.finally(() => {
delete registry[CACHE_KEY];
});
return promise;
};
fetchSkuData().then(d => {
if (!cancelled) setData(d);
}).catch(() => {
if (!cancelled) setHasFetchError(true);
});
return () => {
cancelled = true;
};
}, []);
const textColor = isDark ? '#e6edf3' : '#1f2937';
const textMuted = isDark ? 'rgba(230,237,243,0.65)' : 'rgba(31,41,55,0.65)';
const bannerBackground = isDark ? '#161b22' : '#f6f8fa';
const borderColor = isDark ? 'rgba(38,208,124,0.35)' : 'rgba(38,208,124,0.45)';
const linkColor = isDark ? '#4ade80' : '#047857';
const errorBackground = isDark ? '#3b1111' : '#fef2f2';
const errorBorder = isDark ? '#7f1d1d' : '#fecaca';
const errorText = isDark ? '#fecaca' : '#7f1d1d';
const licensesUrl = data?.licensesPageUrl || FALLBACK_LICENSES_URL;
const resolveSkuName = code => {
const entry = data?.skus?.[code];
if (entry?.name) return entry.name;
return null;
};
const formatSkuLabel = code => {
const name = resolveSkuName(code);
if (name) return name;
return code;
};
const joinWithConjunction = (codes, conjunction) => {
const labels = codes.map(formatSkuLabel);
if (labels.length === 0) return '';
if (labels.length === 1) return labels[0];
if (labels.length === 2) return `${labels[0]} ${conjunction} ${labels[1]}`;
const head = labels.slice(0, -1).join(', ');
const tail = labels[labels.length - 1];
return `${head}, ${conjunction} ${tail}`;
};
const buildSkuSentence = codes => {
const conj = CONJUNCTION[relation] || CONJUNCTION.any;
const names = joinWithConjunction(codes, conj);
const noun = codes.length > 1 ? 'licenses' : 'license';
return `${names} ${noun}`;
};
const renderLink = text =>
{text} →
;
const renderBanner = codes =>
Requires
{buildSkuSentence(codes)}
{renderLink('Licenses')}
;
const renderLoading = () =>
Loading license info…
;
const renderInputError = message =>
{message}
;
if (typeof sku === 'string' && Array.isArray(skus)) {
return renderInputError('LicenseBadge: pass either `sku` or `skus`, not both.');
}
if (skuList.length === 0) {
return renderInputError('LicenseBadge: `sku` or `skus` is required.');
}
if (hasFetchError) return renderBanner(skuList);
if (!data) return renderLoading();
return renderBanner(skuList);
};
export const Diagram = ({children}) => {
const [svg, setSvg] = useState('');
const [error, setError] = useState(null);
const [mounted, setMounted] = useState(false);
const [id] = useState(() => `diagram-${Math.random().toString(36).slice(2)}`);
const DEFAULTS = {
theme: 'base',
fontSize: '14px',
fontFamily: 'inherit',
primaryColor: '#26D07C',
primaryTextColor: '#000000',
primaryBorderColor: '#059669',
secondaryColor: '#e5e7eb',
secondaryTextColor: '#000000',
secondaryBorderColor: '#9ca3af',
tertiaryColor: '#e5e7eb',
tertiaryTextColor: '#000000',
tertiaryBorderColor: '#9ca3af',
lineColor: '#6b7280',
background: '#ffffff',
edgeLabelBackground: '#f9fafb',
clusterBkg: '#f0fdf4',
clusterBorder: '#059669',
nodeTextColor: '#000000',
endorColor: '#26D07C',
endorBorder: '#059669',
managedColor: '#A7F3D0',
managedBorder: '#059669',
externalColor: '#e5e7eb',
externalBorder: '#9ca3af'
};
const VAR_LINE_RE = /^(\w+):\s*(.+)$/;
const TOKEN_RE = /\{\{(\w+)\}\}/g;
const parseVarsBlock = raw => {
const vars = {};
const lines = raw.trim().split('\n');
const diagramLines = [];
let inVars = false;
for (const line of lines) {
const trimmed = line.trim();
if (trimmed === '%%vars') {
inVars = true;
continue;
}
if (inVars && trimmed === '%%') {
inVars = false;
continue;
}
if (inVars) {
const m = VAR_LINE_RE.exec(trimmed);
if (m) vars[m[1]] = m[2];
} else {
diagramLines.push(line);
}
}
return {
vars,
diagramLines
};
};
const buildInitConfig = merged => ({
theme: merged.theme,
themeVariables: {
fontSize: merged.fontSize,
fontFamily: merged.fontFamily,
primaryColor: merged.primaryColor,
primaryTextColor: merged.primaryTextColor,
primaryBorderColor: merged.primaryBorderColor,
secondaryColor: merged.secondaryColor,
secondaryTextColor: merged.secondaryTextColor,
secondaryBorderColor: merged.secondaryBorderColor,
tertiaryColor: merged.tertiaryColor,
tertiaryTextColor: merged.tertiaryTextColor,
tertiaryBorderColor: merged.tertiaryBorderColor,
lineColor: merged.lineColor,
background: merged.background,
edgeLabelBackground: merged.edgeLabelBackground,
clusterBkg: merged.clusterBkg,
clusterBorder: merged.clusterBorder,
nodeTextColor: merged.nodeTextColor
}
});
const renderWithMermaid = (mermaid, fullDiagram) => {
mermaid.initialize({
startOnLoad: false,
zoom: {
enabled: false
}
});
mermaid.render(id, fullDiagram).then(({svg: rendered}) => {
setSvg(rendered);
setError(null);
}).catch(err => setError(err.message));
};
useEffect(() => {
setMounted(true);
}, []);
useEffect(() => {
if (!mounted || !children) return;
const raw = typeof children === 'string' ? children : String(children);
const {vars, diagramLines} = parseVarsBlock(raw);
const merged = {
...DEFAULTS,
...vars
};
const diagram = diagramLines.join('\n').trim().replaceAll(TOKEN_RE, (_, key) => merged[key] || '');
const fullDiagram = `%%{init: ${JSON.stringify(buildInitConfig(merged))}}%%\n${diagram}`;
const existing = document.getElementById(id);
if (existing) existing.remove();
if (globalThis.mermaid) {
renderWithMermaid(globalThis.mermaid, fullDiagram);
} else {
const script = document.createElement('script');
script.src = 'https://cdn.jsdelivr.net/npm/mermaid@11/dist/mermaid.min.js';
script.onload = () => renderWithMermaid(globalThis.mermaid, fullDiagram);
script.onerror = () => setError('Failed to load Mermaid');
document.head.appendChild(script);
}
}, [mounted, children, id]);
if (!mounted) return null;
if (error) {
return
Diagram error: {error}
;
}
if (!svg) {
return
Loading diagram...
;
}
return
;
};
export const YamlTable = ({children, data: propData, content}) => {
const KV_RE = /^([A-Za-z][A-Za-z0-9_()/#\s-]+?):\s*(.+)$/;
const INLINE_MD_RE = /(\[([^\]]+)\]\(([^)]+)\))|(`([^`]+)`)|(\*\*([^*]+)\*\*)|(\*([^*]+)\*)/g;
const YES_RE = /^-yes-$/i;
const NO_RE = /^-no-$/i;
const LIMITED_RE = /^-(limited|partial)-$/i;
const NA_RE = /^-(na|none)-$/i;
const NA2_RE = /^-na2-$/i;
const SIMPLE_TAG_RE = /()|()|(-note-)|(-warning-)/gi;
const renderSuccessIcon = () =>
;
const renderFailureIcon = () =>
;
const renderPartialSuccessIcon = () =>
;
const renderPendingIcon = () =>
;
const renderRunningIcon = () =>
;
const renderSkippedIcon = () =>
;
const STATUS_ICON_DEFS = [{
re: /^-status-success-$/i,
colorClass: 'yt-status-color-success',
label: 'Success',
render: renderSuccessIcon
}, {
re: /^-status-failure-$/i,
colorClass: 'yt-status-color-failure',
label: 'Failure',
render: renderFailureIcon
}, {
re: /^-status-partial-success-$/i,
colorClass: 'yt-status-color-partial',
label: 'Partial success',
render: renderPartialSuccessIcon
}, {
re: /^-status-pending-$/i,
colorClass: 'yt-status-color-neutral',
label: 'Pending',
render: renderPendingIcon
}, {
re: /^-status-running-$/i,
colorClass: 'yt-status-color-neutral',
label: 'Running',
render: renderRunningIcon
}, {
re: /^-status-skipped-$/i,
colorClass: 'yt-status-color-neutral',
label: 'Skipped',
render: renderSkippedIcon
}];
const renderStatusBadge = def =>
{def.render()}
;
const tryParseKV = trimmed => {
const m = KV_RE.exec(trimmed);
return m ? {
key: m[1],
value: m[2].trim()
} : null;
};
const registerKey = (key, seenKeys, orderedKeys) => {
if (!seenKeys.has(key)) {
orderedKeys.push(key);
seenKeys.add(key);
}
};
const flushEntry = (currentEntry, entries) => {
if (Object.keys(currentEntry).length > 0) entries.push(currentEntry);
};
const parseDashPrefixed = (lines, entries, orderedKeys, seenKeys) => {
let currentEntry = {};
let inEntry = false;
for (const line of lines) {
const trimmed = line.trim();
if (trimmed.startsWith('- ')) {
if (inEntry) entries.push(currentEntry);
currentEntry = {};
inEntry = true;
const kv = tryParseKV(trimmed.substring(2).trim());
if (kv) {
registerKey(kv.key, seenKeys, orderedKeys);
currentEntry[kv.key] = kv.value;
}
} else if (inEntry && trimmed !== '') {
const kv = tryParseKV(trimmed);
if (kv) {
registerKey(kv.key, seenKeys, orderedKeys);
currentEntry[kv.key] = kv.value;
}
}
}
flushEntry(currentEntry, entries);
};
const parseBlankSeparated = (lines, entries, orderedKeys, seenKeys) => {
let currentEntry = {};
let inEntry = false;
for (const line of lines) {
const trimmed = line.trim();
if (trimmed === '') {
if (inEntry) {
flushEntry(currentEntry, entries);
currentEntry = {};
inEntry = false;
}
continue;
}
const kv = tryParseKV(trimmed);
if (!kv) continue;
const isNewEntry = !line.startsWith(' ') && !line.startsWith('\t');
if (isNewEntry && inEntry && Object.keys(currentEntry).length > 0) {
entries.push(currentEntry);
currentEntry = {};
}
registerKey(kv.key, seenKeys, orderedKeys);
currentEntry[kv.key] = kv.value;
inEntry = true;
}
flushEntry(currentEntry, entries);
};
const normalizeEntries = (entries, orderedKeys) => entries.map(entry => {
const filled = {};
for (const key of orderedKeys) filled[key] = entry[key] || '';
return filled;
});
const parseYamlTableContent = contentStr => {
if (!contentStr) return [];
const entries = [];
const orderedKeys = [];
const seenKeys = new Set();
const lines = contentStr.split('\n');
if (lines.some(line => line.trim().startsWith('- '))) {
parseDashPrefixed(lines, entries, orderedKeys, seenKeys);
} else {
parseBlankSeparated(lines, entries, orderedKeys, seenKeys);
}
return normalizeEntries(entries, orderedKeys);
};
const processText = text => {
if (!text) return text;
const parts = [];
let keyIndex = 0;
let lastIndex = 0;
let match;
while ((match = INLINE_MD_RE.exec(text)) !== null) {
if (match.index > lastIndex) parts.push(text.slice(lastIndex, match.index));
if (match[1]) {
parts.push({match[2]} );
} else if (match[4]) {
parts.push({match[5]});
} else if (match[6]) {
parts.push({match[7]} );
} else if (match[8]) {
parts.push({match[9]} );
}
lastIndex = match.index + match[0].length;
}
if (lastIndex < text.length) parts.push(text.slice(lastIndex));
if (parts.length === 0) return text;
const keyRef = {
current: keyIndex
};
return expandHtmlTags(parts, keyRef);
};
const processBadges = text => {
if (!text || typeof text !== 'string') return text;
if (YES_RE.test(text)) return ✓ ;
if (NO_RE.test(text)) return ✗ ;
if (LIMITED_RE.test(text)) return ◐ ;
if (NA_RE.test(text) || NA2_RE.test(text)) return Not applicable ;
const statusBadge = STATUS_ICON_DEFS.find(def => def.re.test(text));
if (statusBadge) return renderStatusBadge(statusBadge);
return processText(text);
};
const cellClassName = text => {
if (!text || typeof text !== 'string') return undefined;
if (NA_RE.test(text)) return 'yt-cell-na';
if (NA2_RE.test(text)) return 'yt-cell-na2';
return undefined;
};
const expandSimpleTags = (str, keyRef) => {
const result = [];
let last = 0;
SIMPLE_TAG_RE.lastIndex = 0;
let m;
while ((m = SIMPLE_TAG_RE.exec(str)) !== null) {
if (m.index > last) result.push(str.slice(last, m.index));
if (m[1]) {
result.push(Note: );
} else if (m[4]) {
result.push(Warning: );
}
last = m.index + m[0].length;
}
if (last < str.length) result.push(str.slice(last));
return result;
};
const expandHtmlTags = (chunks, keyRef) => {
const out = [];
for (const chunk of chunks) {
if (typeof chunk === 'string') {
out.push(...expandSimpleTags(chunk, keyRef));
} else {
out.push(chunk);
}
}
return out;
};
const extractText = node => {
if (node === null || node === undefined) return '';
if (typeof node === 'string') return node;
if (typeof node === 'number') return String(node);
if (typeof node === 'boolean') return '';
if (Array.isArray(node)) return node.map(extractText).join('');
if (node && typeof node === 'object' && node.type) {
const props = node.props || ({});
if (typeof props.children === 'string') return props.children;
if (props.children) return extractText(props.children);
return '';
}
return String(node || '');
};
const [mounted, setMounted] = useState(false);
const scrollWrapRef = useRef(null);
const [isScrollable, setIsScrollable] = useState(false);
useEffect(() => {
setMounted(true);
}, []);
const data = useMemo(() => {
if (propData) return propData;
if (content && typeof content === 'string') return parseYamlTableContent(content);
if (!children) return [];
if (typeof children === 'string') return parseYamlTableContent(children);
const childrenArray = Array.isArray(children) ? children : [children];
return parseYamlTableContent(childrenArray.map(extractText).join('').trim());
}, [children, propData, content]);
const columns = useMemo(() => {
if (!data || data.length === 0) return [];
const firstRow = data[0];
if (!firstRow || typeof firstRow !== 'object') return [];
return Object.keys(firstRow);
}, [data]);
useEffect(() => {
const wrap = scrollWrapRef.current;
if (!wrap) return undefined;
const updateScrollable = () => {
setIsScrollable(wrap.scrollWidth > wrap.clientWidth);
};
updateScrollable();
const observer = new ResizeObserver(updateScrollable);
observer.observe(wrap);
return () => observer.disconnect();
}, [mounted, data]);
if (!mounted) return null;
if (!data || data.length === 0) return null;
const rowKey = row => columns.map(c => row[c] || '').join('|');
return
{columns.map(col => {col.replaceAll('_', ' ')} )}
{data.map(row =>
{columns.map(col => {processBadges(row[col])} )}
)}
;
};
{`
- Term: Private package registry
Examples: JFrog Artifactory (SaaS and self-managed), Sonatype Nexus Repository, Google Artifact Registry
- Term: Package manager client
Examples: npm, pnpm, Yarn, pip, uv, Poetry, Maven, Go
- Term: Public registry
Examples: npmjs.com, pypi.org, pkg.go.dev, Maven Central
`}
## Private package registry
Use this model if developers already install packages through JFrog Artifactory, Sonatype Nexus Repository, or Google Artifact Registry.
Your private package registry uses Package Firewall as its remote source. Package manager clients keep talking to the registry they already use. The registry forwards each request to the firewall.
{`
flowchart LR
PMC[Package manager client]
REG[Private package registry]
PF[Package Firewall]
PUB[Public registry]
PMC --> REG
REG --> PF
PF --> PUB
`}
Configure the registry you already run.
Point Artifactory remote repositories at Package Firewall.
Point Artifact Registry remote repositories at Package Firewall.
Point Nexus proxy repositories at Package Firewall.
## Package manager client
Use this model if you don't run a private package registry, or if you want machines to talk to Package Firewall directly.
You configure each package manager client with the Package Firewall URL and credentials. Do that by hand on each machine, or push the configuration with MDM.
{`
flowchart LR
PMC[Package manager client]
PF[Package Firewall]
PUB[Public registry]
PMC --> PF
PF --> PUB
`}
Choose how you configure the clients.
Configure npm, pip, uv, Yarn, Maven, and other clients to use Package Firewall.
Push the same client configuration to developer machines with your MDM tool.
## Compare the models
The following table summarizes how the two models differ. In both models, Package Firewall fetches packages from public registries.
{`
- Consideration: Developers install through
Private_package_registry: Artifactory, Nexus, or Google Artifact Registry
Package_manager_client: npm, pip, uv, Yarn, Maven, and other clients
- Consideration: Who sets the Package Firewall URL
Private_package_registry: Registry administrators
Package_manager_client: Each developer, or IT with MDM
- Consideration: Typical fit
Private_package_registry: You already run a private package registry
Package_manager_client: No private package registry, or you want per-machine control
`}
## Next steps
After you route traffic through Package Firewall, configure how it responds to flagged packages. See [Package Firewall policy](/package-firewall/policy) to set block, warn, and allow safe versions actions.