netzilo 4.3.14

package/dist/loader.js

@@ -0,0 +1,157 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.load = load;
+exports._resetForTests = _resetForTests;
+exports.tmpDir = tmpDir;
+/**
+ * koffi loader for the embedded Netzilo native client.
+ *
+ * Resolves the platform-specific binary and binds the exported symbols with
+ * correct signatures.
+ *
+ * koffi (not the older/stale ffi-napi) is used: it ships prebuilt native
+ * bindings per platform, so installing this package never requires a C
+ * compiler or node-gyp on the consumer's machine.
+ */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const platformPkg_1 = require("./platformPkg");
+let cached = null;
+function libFilename() {
+    switch (process.platform) {
+        case "darwin":
+            return "netzilo.dylib";
+        case "win32":
+            return "netzilo.dll";
+        default:
+            return "netzilo.so";
+    }
+}
+function libPath() {
+    // Allow an override for development / custom builds.
+    const override = process.env.NETZILO_LIB_PATH;
+    if (override) {
+        return override;
+    }
+    // Production path: the optional per-platform package (e.g.
+    // netzilo-darwin-arm64), installed automatically by npm based on the
+    // consumer's platform/arch.
+    const platformDir = (0, platformPkg_1.resolvePlatformLibDir)();
+    if (platformDir) {
+        const candidate = path.join(platformDir, libFilename());
+        if (fs.existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    // Local monorepo dev fallback: a binary dropped directly into _lib/.
+    return path.join(__dirname, "..", "_lib", libFilename());
+}
+function noop() {
+    // Intentionally empty — used for exports absent in older bundled libraries.
+}
+function load() {
+    if (cached) {
+        return cached;
+    }
+    const resolvedPath = libPath();
+    if (!fs.existsSync(resolvedPath)) {
+        throw new Error(`netzilo: shared library not found at ${resolvedPath}. ` +
+            "This package may not include a binary for your platform, or set " +
+            "NETZILO_LIB_PATH to a locally built lib.");
+    }
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const koffi = require("koffi");
+    const lib = koffi.load(resolvedPath);
+    const start = lib.func("int Start(str configJSON)");
+    const stop = lib.func("int Stop()");
+    const isRunning = lib.func("int IsRunning()");
+    // Evaluate returns a heap-allocated char* that must be released with
+    // FreeString. A koffi "disposable type" wraps 'str' so koffi decodes the
+    // pointer to a JS string AND calls FreeString on the original pointer
+    // immediately after — the caller never touches the pointer, so there is no
+    // manual free step (and no way to double-free or use-after-free it).
+    const freeString = lib.func("void FreeString(void *s)");
+    // disposable() registers the named type globally and returns a type token
+    // (for the array-style declaration form) — the prototype-string form below
+    // references it by the registered NAME, not by that return value.
+    koffi.disposable("NetziloHeapStr", "str", freeString);
+    const evaluate = lib.func("NetziloHeapStr Evaluate(str reqJSON)");
+    // FlushEvents/FlushSnapshot/GetIntegrityLevel may be absent in older
+    // bundled libraries; bind defensively.
+    let flushEvents = noop;
+    let flushSnapshot = noop;
+    let getIntegrityLevel = () => 2; // medium — the documented default
+    try {
+        flushEvents = lib.func("void FlushEvents()");
+    }
+    catch {
+        // absent in this build — keep the no-op
+    }
+    try {
+        flushSnapshot = lib.func("void FlushSnapshot()");
+    }
+    catch {
+        // absent in this build — keep the no-op
+    }
+    try {
+        getIntegrityLevel = lib.func("int GetIntegrityLevel()");
+    }
+    catch {
+        // absent in this build — keep the medium-default fallback
+    }
+    cached = {
+        Start: (configJSON) => start(configJSON),
+        Stop: () => stop(),
+        IsRunning: () => isRunning(),
+        Evaluate: (reqJSON) => evaluate(reqJSON),
+        FlushEvents: () => {
+            flushEvents();
+        },
+        FlushSnapshot: () => {
+            flushSnapshot();
+        },
+        GetIntegrityLevel: () => getIntegrityLevel(),
+    };
+    return cached;
+}
+/** Test-only: forget the cached binding so a fresh NETZILO_LIB_PATH can be picked up. */
+function _resetForTests() {
+    cached = null;
+}
+function tmpDir() {
+    return process.env.TMPDIR || os.tmpdir() || "/tmp";
+}

package/dist/platformPkg.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Directory of the installed platform package, or null if none is installed
+ * (unsupported platform/arch, or the optional dependency wasn't installed).
+ * Never throws.
+ */
+export declare function resolvePlatformLibDir(): string | null;

package/dist/platformPkg.js

@@ -0,0 +1,89 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolvePlatformLibDir = resolvePlatformLibDir;
+/**
+ * Resolves the optional per-platform binary package for the current
+ * platform/arch — e.g. `netzilo-darwin-arm64`, `netzilo-linux-x64`. Each
+ * ships exactly one platform's binaries (netzilo.dylib/.so/.dll, and probe.so
+ * on Linux) as an npm `optionalDependency` of the main `netzilo` package, so
+ * `npm install netzilo` only ever downloads the one matching the install
+ * target.
+ */
+const path = __importStar(require("path"));
+const SUPPORTED = {
+    darwin: ["arm64", "x64"],
+    linux: ["arm64", "x64"],
+    win32: ["x64"],
+};
+// Package name overrides for platform/arch pairs that don't follow the plain
+// `netzilo-${platform}-${arch}` pattern. Currently just win32-x64: npm's
+// automated spam detection flagged the exact string "netzilo-win32-x64" for
+// this account (reproduced directly — publishing that exact name fails with
+// a 403 regardless of content/version, while every other name, including
+// ones containing "win32", publishes fine) and blocked publishing under it.
+// Renamed to netzilo-windows-x64 as the unblock; a support ticket with npm
+// covers reclaiming the original name later if ever needed.
+const NAME_OVERRIDES = {
+    "win32-x64": "netzilo-windows-x64",
+};
+function platformPackageName() {
+    const platform = process.platform;
+    const arch = process.arch;
+    if (!SUPPORTED[platform] || !SUPPORTED[platform].includes(arch)) {
+        return null;
+    }
+    const key = `${platform}-${arch}`;
+    return NAME_OVERRIDES[key] || `netzilo-${key}`;
+}
+/**
+ * Directory of the installed platform package, or null if none is installed
+ * (unsupported platform/arch, or the optional dependency wasn't installed).
+ * Never throws.
+ */
+function resolvePlatformLibDir() {
+    const pkgName = platformPackageName();
+    if (!pkgName) {
+        return null;
+    }
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const pkgJsonPath = require.resolve(`${pkgName}/package.json`);
+        return path.dirname(pkgJsonPath);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/probe.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Datagram socket path shared by the probe and the native client's receiver.
+ *
+ * MUST match the receiver's own default (derived from the OS temp dir and
+ * this process's pid). The native runtime does NOT observe NETZILO_PROBE_SOCK
+ * that Node sets at runtime, so it falls back to this default — both sides
+ * therefore have to agree on it independently. The pid makes it unique per
+ * process so two co-located embedded agents don't collide; the embedded
+ * native runtime is THIS process, so its pid equals ours and it computes the
+ * identical path.
+ */
+export declare function socketPath(): string;
+/**
+ * Publish NETZILO_PROBE_SOCK BEFORE the native client starts, so its receiver
+ * binds the exact path the probe will later connect to (no startup race).
+ * Linux-only; respects an explicit caller override; idempotent.
+ */
+export declare function primeSocketEnv(_configDir: string): void;
+/**
+ * Inject the probe into this process and all future subprocesses. Linux only;
+ * idempotent; never throws. Returns true if injected.
+ */
+export declare function install(configDir: string): boolean;
+/**
+ * Restore LD_PRELOAD so subprocesses spawned after stop() don't load the
+ * probe. The in-process dlopen can't be undone, but the probe fails open once
+ * the receiver socket is gone. Idempotent; never throws.
+ */
+export declare function uninstall(): void;

package/dist/probe.js

@@ -0,0 +1,241 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.socketPath = socketPath;
+exports.primeSocketEnv = primeSocketEnv;
+exports.install = install;
+exports.uninstall = uninstall;
+/**
+ * In-process security-probe injection for advanced governance (Linux only).
+ *
+ * When enableAdvancedGovernance is on, the agent's process activity — process
+ * creation and filesystem access, for the agent itself AND every subprocess it
+ * spawns (curl, git, python, shell pipelines, ...) — is monitored by a
+ * userspace probe injected via LD_PRELOAD. The probe emits the same
+ * SecurityEvent stream the macOS Endpoint Security extension produces, over
+ * an AF_UNIX datagram socket to the embedded native client's receiver.
+ *
+ * Two injection vectors, both required for full parity with the macOS
+ * extension:
+ *   - dlopen the probe into THIS process so the agent runtime itself is hooked
+ *     (LD_PRELOAD cannot retroactively hook an already-running process);
+ *   - prepend the probe to LD_PRELOAD so every subprocess loads it on exec.
+ *
+ * Gated entirely behind advanced governance: with it off, nothing is injected
+ * and the probe socket is never primed, so no hooks exist. Linux-only — a
+ * no-op on macOS (the ES extension covers everything) and Windows. Idempotent;
+ * never throws — probe setup must not break the agent.
+ */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const platformPkg_1 = require("./platformPkg");
+const PROBE_SOCK_ENV = "NETZILO_PROBE_SOCK";
+const PROBE_IGNORE_ENV = "NETZILO_PROBE_IGNORE";
+let installed = false;
+let priorLdPreload;
+// The dlopened probe MUST stay loaded for the process lifetime: its inline
+// hooks are patched into libc, so unloading it would leave those patches
+// jumping into freed memory. Holding the koffi handle in this module keeps a
+// reference alive for the process lifetime (never unloaded — the hooks can't
+// be cleanly removed anyway).
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let probeHandle = null;
+function isLinux() {
+    return process.platform === "linux";
+}
+function probeLibPath() {
+    // NETZILO_PROBE_PATH overrides for development / custom builds.
+    const override = process.env.NETZILO_PROBE_PATH;
+    if (override) {
+        return override;
+    }
+    // Production path: ships alongside netzilo.so in the Linux platform
+    // package (netzilo-linux-x64 / netzilo-linux-arm64).
+    const platformDir = (0, platformPkg_1.resolvePlatformLibDir)();
+    if (platformDir) {
+        const candidate = path.join(platformDir, "probe.so");
+        if (fs.existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    // Local monorepo dev fallback: a binary dropped directly into _lib/.
+    return path.join(__dirname, "..", "_lib", "probe.so");
+}
+/**
+ * Datagram socket path shared by the probe and the native client's receiver.
+ *
+ * MUST match the receiver's own default (derived from the OS temp dir and
+ * this process's pid). The native runtime does NOT observe NETZILO_PROBE_SOCK
+ * that Node sets at runtime, so it falls back to this default — both sides
+ * therefore have to agree on it independently. The pid makes it unique per
+ * process so two co-located embedded agents don't collide; the embedded
+ * native runtime is THIS process, so its pid equals ours and it computes the
+ * identical path.
+ */
+function socketPath() {
+    const base = process.env.TMPDIR || "/tmp";
+    return path.join(base, `netzilo-probe-${process.pid}.sock`);
+}
+/**
+ * Publish NETZILO_PROBE_SOCK BEFORE the native client starts, so its receiver
+ * binds the exact path the probe will later connect to (no startup race).
+ * Linux-only; respects an explicit caller override; idempotent.
+ */
+function primeSocketEnv(_configDir) {
+    if (!isLinux()) {
+        return;
+    }
+    if (!process.env[PROBE_SOCK_ENV]) {
+        process.env[PROBE_SOCK_ENV] = socketPath();
+    }
+}
+function setIgnorePrefixes(configDir) {
+    // Publish ':'-separated path prefixes the probe should NOT report — the
+    // client's own state dir and the bundled-library dir — so the embedded
+    // native client's internal I/O doesn't pollute the behavior graph.
+    // Preserves any caller-provided prefixes. Idempotent.
+    const prefixes = [];
+    if (configDir) {
+        prefixes.push(configDir);
+    }
+    const libDir = path.dirname(probeLibPath());
+    if (libDir) {
+        prefixes.push(libDir);
+    }
+    const existing = process.env[PROBE_IGNORE_ENV];
+    if (existing) {
+        prefixes.push(existing);
+    }
+    // De-dup while preserving order; the probe caps at a small fixed count.
+    const seen = new Set();
+    const ordered = [];
+    for (const p of prefixes.join(":").split(":")) {
+        if (p && !seen.has(p)) {
+            seen.add(p);
+            ordered.push(p);
+        }
+    }
+    process.env[PROBE_IGNORE_ENV] = ordered.join(":");
+}
+/**
+ * Inject the probe into this process and all future subprocesses. Linux only;
+ * idempotent; never throws. Returns true if injected.
+ */
+function install(configDir) {
+    if (installed) {
+        return true;
+    }
+    if (!isLinux()) {
+        return false;
+    }
+    try {
+        const probe = probeLibPath();
+        if (!fs.existsSync(probe)) {
+            // eslint-disable-next-line no-console
+            console.log(`netzilo.probe: probe.so not bundled at ${probe} — skipping`);
+            return false;
+        }
+        // The receiver should already have this from primeSocketEnv(); set it
+        // defensively so the probe can find the socket regardless of order.
+        if (!process.env[PROBE_SOCK_ENV]) {
+            process.env[PROBE_SOCK_ENV] = socketPath();
+        }
+        // Tell the probe to ignore the client's OWN file I/O so the embedded
+        // native client (netzilo.so, hosted in this same process) doesn't
+        // pollute the behavior graph with its config/db/CA/WASM reads+writes.
+        // Covers both the in-process self-hook and subprocesses (which inherit
+        // the env).
+        setIgnorePrefixes(configDir);
+        // 1) Subprocesses: prepend the probe to LD_PRELOAD, preserving any
+        // existing entries (e.g. a sanitizer or another interposer). Node
+        // subprocesses spawned via child_process inherit process.env by default.
+        priorLdPreload = process.env.LD_PRELOAD;
+        process.env.LD_PRELOAD = [probe, priorLdPreload].filter(Boolean).join(" ");
+        // 2) This process: dlopen so the agent runtime itself is hooked.
+        // LD_PRELOAD is read only at exec, so it cannot hook the already-running
+        // process; loading it now runs the probe's constructor in-process. The
+        // probe is reentrancy-guarded and fails open, so this is safe in a live
+        // Node process. Set NETZILO_PROBE_SELF=0 to cover only subprocesses
+        // (LD_PRELOAD) and skip hooking this process.
+        if (!["0", "false", "no"].includes(process.env.NETZILO_PROBE_SELF ?? "1")) {
+            try {
+                // eslint-disable-next-line @typescript-eslint/no-var-requires
+                const koffi = require("koffi");
+                // Pin the handle (see module comment) so it is never garbage
+                // collected/unloaded out from under the installed hooks.
+                probeHandle = koffi.load(probe);
+            }
+            catch (exc) {
+                // eslint-disable-next-line no-console
+                console.warn("netzilo.probe: in-process dlopen failed (agent self-hook off):", exc);
+            }
+        }
+        installed = true;
+        // eslint-disable-next-line no-console
+        console.log(`netzilo.probe: injected (LD_PRELOAD + in-process), sock=${process.env[PROBE_SOCK_ENV]}`);
+        return true;
+    }
+    catch (exc) {
+        // eslint-disable-next-line no-console
+        console.warn("netzilo.probe: install failed:", exc);
+        return false;
+    }
+}
+/**
+ * Restore LD_PRELOAD so subprocesses spawned after stop() don't load the
+ * probe. The in-process dlopen can't be undone, but the probe fails open once
+ * the receiver socket is gone. Idempotent; never throws.
+ */
+function uninstall() {
+    if (!installed) {
+        return;
+    }
+    try {
+        if (priorLdPreload === undefined) {
+            delete process.env.LD_PRELOAD;
+        }
+        else {
+            process.env.LD_PRELOAD = priorLdPreload;
+        }
+    }
+    catch (exc) {
+        // eslint-disable-next-line no-console
+        console.warn("netzilo.probe: uninstall failed:", exc);
+    }
+    finally {
+        priorLdPreload = undefined;
+        installed = false;
+    }
+}

package/dist/trust.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Make the current process trust the MITM CA. Idempotent; no-op if the CA
+ * isn't present (MITM disabled). Never throws — trust setup must not break
+ * the agent. Returns true if trust was applied.
+ */
+export declare function installTrust(configDir: string, waitSecs?: number): Promise<boolean>;
+/**
+ * Route this process's (and subprocesses') traffic through the unified proxy
+ * so it can be governed. Sets standard proxy env vars (covers subprocesses
+ * and any proxy-env-aware library) and, when the optional `undici` peer
+ * dependency is installed, wires undici's EnvHttpProxyAgent as the global
+ * dispatcher — the mechanism Node's global fetch() actually honors.
+ *
+ * Idempotent; never throws. Returns true if applied.
+ */
+export declare function installRouting(unifiedPort: number, extraNoProxy?: string): boolean;
+/**
+ * Restore the proxy env vars to their pre-install values. Called on stop() so
+ * a long-lived host process that keeps running after stop() does not keep
+ * routing traffic to the (now closed) egress port. Idempotent; never throws.
+ */
+export declare function uninstallRouting(): void;