chainlesschain 0.162.175 → 0.162.176

package/src/lib/json-schema-validate.js

@@ -173,9 +173,7 @@ export function computeSchemaDigest(schema) {
 }
 
 /** Resolve a local `#/...` JSON Pointer $ref within `root`; null if unresolved. */
-function resolveRef(root, ref) {
-  if (typeof ref !== "string" || !ref.startsWith("#")) return null;
-  const frag = ref.slice(1);
+function resolvePointer(root, frag) {
   if (frag === "" || frag === "/") return root;
   const parts = frag
     .replace(/^\//, "")
@@ -189,15 +187,56 @@ function resolveRef(root, ref) {
   return cur === undefined ? null : cur;
 }
 
+function findAnchor(root, anchor, seen = new Set()) {
+  if (!root || typeof root !== "object" || seen.has(root)) return null;
+  seen.add(root);
+  if (root.$anchor === anchor || root.$dynamicAnchor === anchor) return root;
+  for (const value of Object.values(root)) {
+    const found = findAnchor(value, anchor, seen);
+    if (found) return found;
+  }
+  return null;
+}
+
+/** Resolve local refs or a caller-provided external document registry. */
+function resolveRef(root, ref, externalSchemas = {}) {
+  if (typeof ref !== "string") return null;
+  if (ref.startsWith("#")) {
+    const fragment = ref.slice(1);
+    if (fragment === "" || fragment.startsWith("/")) {
+      return resolvePointer(root, fragment);
+    }
+    try {
+      return findAnchor(root, decodeURIComponent(fragment), new Set());
+    } catch {
+      return findAnchor(root, fragment, new Set());
+    }
+  }
+  const hash = ref.indexOf("#");
+  const uri = hash >= 0 ? ref.slice(0, hash) : ref;
+  const document = externalSchemas?.[ref] ?? externalSchemas?.[uri];
+  if (document === undefined) return null;
+  if (hash < 0) return document;
+  const fragment = ref.slice(hash + 1);
+  if (fragment === "" || fragment.startsWith("/")) {
+    return resolvePointer(document, fragment);
+  }
+  try {
+    return findAnchor(document, decodeURIComponent(fragment), new Set());
+  } catch {
+    return findAnchor(document, fragment, new Set());
+  }
+}
+
 // ─── instance validation ─────────────────────────────────────────────────────
 
 /**
  * Validate `value` against `schema`.
  * @returns {{valid:boolean, errors:Array<{code,keyword,instancePath,schemaPath,message}>}}
  */
-export function validate(value, schema) {
+export function validate(value, schema, { externalSchemas = {} } = {}) {
   const errors = [];
-  _validate(value, schema, [], [], schema, errors, 0);
+  _validate(value, schema, [], [], schema, errors, 0, externalSchemas);
   return { valid: errors.length === 0, errors };
 }
 
@@ -211,7 +250,7 @@ function _err(errors, keyword, instSegs, schemaSegs, message) {
   });
 }
 
-function _validate(value, schema, inst, sch, root, errors, depth) {
+function _validate(value, schema, inst, sch, root, errors, depth, externalSchemas) {
   if (schema === true || schema === undefined) return;
   if (schema === false) {
     _err(errors, "false", inst, sch, "schema is `false` — no value is valid");
@@ -220,19 +259,25 @@ function _validate(value, schema, inst, sch, root, errors, depth) {
   if (!schema || typeof schema !== "object") return;
   if (depth > MAX_REF_DEPTH) return; // cyclic $ref guard
 
-  // $ref — validate against the referenced schema (local only).
-  if (typeof schema.$ref === "string") {
-    const target = resolveRef(root, schema.$ref);
+  // $ref/$dynamicRef — local pointer/anchor or explicit external registry.
+  const refKeyword =
+    typeof schema.$ref === "string"
+      ? "$ref"
+      : typeof schema.$dynamicRef === "string"
+        ? "$dynamicRef"
+        : null;
+  if (refKeyword) {
+    const target = resolveRef(root, schema[refKeyword], externalSchemas);
     if (target == null) {
       _err(
         errors,
-        "$ref",
+        refKeyword,
         inst,
-        [...sch, "$ref"],
-        `cannot resolve $ref "${schema.$ref}"`,
+        [...sch, refKeyword],
+        `cannot resolve ${refKeyword} "${schema[refKeyword]}"`,
       );
     } else {
-      _validate(value, target, inst, [...sch, "$ref"], root, errors, depth + 1);
+      _validate(value, target, inst, [...sch, refKeyword], root, errors, depth + 1, externalSchemas);
     }
     // sibling keywords still apply in 2020-12; fall through.
   }
@@ -282,12 +327,12 @@ function _validate(value, schema, inst, sch, root, errors, depth) {
   if (t === "number" || t === "integer")
     _validateNumber(value, schema, inst, sch, errors);
   if (t === "array")
-    _validateArray(value, schema, inst, sch, root, errors, depth);
+    _validateArray(value, schema, inst, sch, root, errors, depth, externalSchemas);
   if (t === "object")
-    _validateObject(value, schema, inst, sch, root, errors, depth);
+    _validateObject(value, schema, inst, sch, root, errors, depth, externalSchemas);
 
-  _validateCombinators(value, schema, inst, sch, root, errors, depth);
-  _validateConditional(value, schema, inst, sch, root, errors, depth);
+  _validateCombinators(value, schema, inst, sch, root, errors, depth, externalSchemas);
+  _validateConditional(value, schema, inst, sch, root, errors, depth, externalSchemas);
 }
 
 /**
@@ -295,9 +340,9 @@ function _validate(value, schema, inst, sch, root, errors, depth) {
  * own errors are never reported; if the value matches `if`, `then` applies,
  * otherwise `else` applies. No `if` keyword ⇒ then/else are inert.
  */
-function _validateConditional(value, schema, inst, sch, root, errors, depth) {
+function _validateConditional(value, schema, inst, sch, root, errors, depth, externalSchemas) {
   if (schema.if === undefined) return;
-  const matched = _branchValid(value, schema.if, root, depth);
+  const matched = _branchValid(value, schema.if, root, depth, externalSchemas);
   if (matched) {
     if (schema.then !== undefined) {
       _validate(
@@ -308,10 +353,11 @@ function _validateConditional(value, schema, inst, sch, root, errors, depth) {
         root,
         errors,
         depth,
+        externalSchemas,
       );
     }
   } else if (schema.else !== undefined) {
-    _validate(value, schema.else, inst, [...sch, "else"], root, errors, depth);
+    _validate(value, schema.else, inst, [...sch, "else"], root, errors, depth, externalSchemas);
   }
 }
 
@@ -423,7 +469,7 @@ function _validateNumber(value, schema, inst, sch, errors) {
   }
 }
 
-function _validateArray(value, schema, inst, sch, root, errors, depth) {
+function _validateArray(value, schema, inst, sch, root, errors, depth, externalSchemas) {
   if (Number.isFinite(schema.minItems) && value.length < schema.minItems) {
     _err(
       errors,
@@ -460,6 +506,24 @@ function _validateArray(value, schema, inst, sch, root, errors, depth) {
     }
   }
   const prefix = Array.isArray(schema.prefixItems) ? schema.prefixItems : [];
+  if (schema.contains !== undefined) {
+    const matches = value.reduce(
+      (count, item, i) =>
+        count + (_branchValid(item, schema.contains, root, depth, externalSchemas) ? 1 : 0),
+      0,
+    );
+    const min = Number.isFinite(schema.minContains) ? schema.minContains : 1;
+    const max = Number.isFinite(schema.maxContains) ? schema.maxContains : Infinity;
+    if (matches < min || matches > max) {
+      _err(
+        errors,
+        "contains",
+        inst,
+        [...sch, "contains"],
+        `array contains ${matches} matching item(s), expected ${min}${max === Infinity ? "+" : `..${max}`}`,
+      );
+    }
+  }
   value.forEach((item, i) => {
     if (i < prefix.length) {
       _validate(
@@ -470,6 +534,7 @@ function _validateArray(value, schema, inst, sch, root, errors, depth) {
         root,
         errors,
         depth,
+        externalSchemas,
       );
     } else if (schema.items !== undefined) {
       _validate(
@@ -480,12 +545,13 @@ function _validateArray(value, schema, inst, sch, root, errors, depth) {
         root,
         errors,
         depth,
+        externalSchemas,
       );
     }
   });
 }
 
-function _validateObject(value, schema, inst, sch, root, errors, depth) {
+function _validateObject(value, schema, inst, sch, root, errors, depth, externalSchemas) {
   const keys = Object.keys(value);
   if (
     Number.isFinite(schema.minProperties) &&
@@ -523,6 +589,10 @@ function _validateObject(value, schema, inst, sch, root, errors, depth) {
     }
   }
   const props = schema.properties || {};
+  const patterns = schema.patternProperties || {};
+  const patternEntries = Object.entries(patterns).map(([pattern, sub]) => {
+    try { return [new RegExp(pattern), pattern, sub]; } catch { return [null, pattern, sub]; }
+  });
   for (const [k, v] of Object.entries(value)) {
     if (Object.prototype.hasOwnProperty.call(props, k)) {
       _validate(
@@ -533,19 +603,25 @@ function _validateObject(value, schema, inst, sch, root, errors, depth) {
         root,
         errors,
         depth,
+        externalSchemas,
       );
-    } else if (schema.additionalProperties === false) {
+    } else {
+      const matches = patternEntries.filter(([re]) => re && re.test(k));
+      if (matches.length > 0) {
+        for (const [, pattern, sub] of matches) {
+          _validate(v, sub, [...inst, k], [...sch, "patternProperties", pattern], root, errors, depth, externalSchemas);
+        }
+        continue;
+      }
+      if (schema.additionalProperties === false || schema.unevaluatedProperties === false) {
       _err(
         errors,
-        "additionalProperties",
+        schema.additionalProperties === false ? "additionalProperties" : "unevaluatedProperties",
         [...inst, k],
-        [...sch, "additionalProperties"],
+        [...sch, schema.additionalProperties === false ? "additionalProperties" : "unevaluatedProperties"],
         `unexpected property "${k}"`,
       );
-    } else if (
-      schema.additionalProperties &&
-      typeof schema.additionalProperties === "object"
-    ) {
+      } else if (schema.additionalProperties && typeof schema.additionalProperties === "object") {
       _validate(
         v,
         schema.additionalProperties,
@@ -554,25 +630,49 @@ function _validateObject(value, schema, inst, sch, root, errors, depth) {
         root,
         errors,
         depth,
+        externalSchemas,
       );
+      }
+    }
+  }
+  if (schema.propertyNames !== undefined) {
+    for (const key of keys) {
+      _validate(key, schema.propertyNames, [...inst, key], [...sch, "propertyNames"], root, errors, depth, externalSchemas);
+    }
+  }
+  if (schema.dependentRequired && typeof schema.dependentRequired === "object") {
+    for (const [key, required] of Object.entries(schema.dependentRequired)) {
+      if (!Object.prototype.hasOwnProperty.call(value, key)) continue;
+      for (const dep of Array.isArray(required) ? required : []) {
+        if (!Object.prototype.hasOwnProperty.call(value, dep)) {
+          _err(errors, "dependentRequired", inst, [...sch, "dependentRequired", key], `property "${key}" requires property "${dep}"`);
+        }
+      }
+    }
+  }
+  if (schema.dependentSchemas && typeof schema.dependentSchemas === "object") {
+    for (const [key, sub] of Object.entries(schema.dependentSchemas)) {
+      if (Object.prototype.hasOwnProperty.call(value, key)) {
+        _validate(value, sub, inst, [...sch, "dependentSchemas", key], root, errors, depth, externalSchemas);
+      }
     }
   }
 }
 
-function _branchValid(value, subschema, root, depth) {
+function _branchValid(value, subschema, root, depth, externalSchemas) {
   const errs = [];
-  _validate(value, subschema, [], [], root, errs, depth + 1);
+  _validate(value, subschema, [], [], root, errs, depth + 1, externalSchemas);
   return errs.length === 0;
 }
 
-function _validateCombinators(value, schema, inst, sch, root, errors, depth) {
+function _validateCombinators(value, schema, inst, sch, root, errors, depth, externalSchemas) {
   if (Array.isArray(schema.allOf)) {
     schema.allOf.forEach((s, i) => {
-      _validate(value, s, inst, [...sch, "allOf", i], root, errors, depth);
+      _validate(value, s, inst, [...sch, "allOf", i], root, errors, depth, externalSchemas);
     });
   }
   if (Array.isArray(schema.anyOf)) {
-    const ok = schema.anyOf.some((s) => _branchValid(value, s, root, depth));
+    const ok = schema.anyOf.some((s) => _branchValid(value, s, root, depth, externalSchemas));
     if (!ok)
       _err(
         errors,
@@ -584,7 +684,7 @@ function _validateCombinators(value, schema, inst, sch, root, errors, depth) {
   }
   if (Array.isArray(schema.oneOf)) {
     const matches = schema.oneOf.filter((s) =>
-      _branchValid(value, s, root, depth),
+      _branchValid(value, s, root, depth, externalSchemas),
     ).length;
     if (matches !== 1) {
       _err(
@@ -598,7 +698,7 @@ function _validateCombinators(value, schema, inst, sch, root, errors, depth) {
   }
   if (
     schema.not !== undefined &&
-    _branchValid(value, schema.not, root, depth)
+    _branchValid(value, schema.not, root, depth, externalSchemas)
   ) {
     _err(
       errors,
@@ -692,6 +792,8 @@ function _metaValidate(schema, segs, errors, depth) {
     "maxItems",
     "minProperties",
     "maxProperties",
+    "minContains",
+    "maxContains",
   ]) {
     if (
       schema[k] !== undefined &&
@@ -724,6 +826,28 @@ function _metaValidate(schema, segs, errors, depth) {
   if (schema.$ref !== undefined && typeof schema.$ref !== "string") {
     _metaErr(errors, "$ref", [...segs, "$ref"], "$ref must be a string");
   }
+  for (const k of ["$id", "$schema", "$anchor", "$dynamicAnchor", "$dynamicRef", "$comment"]) {
+    if (schema[k] !== undefined && typeof schema[k] !== "string") {
+      _metaErr(errors, k, [...segs, k], `${k} must be a string`);
+    }
+  }
+  if (schema.$anchor !== undefined && typeof schema.$anchor === "string" && !/^[A-Za-z][A-Za-z0-9:_-]*$/.test(schema.$anchor)) {
+    _metaErr(errors, "$anchor", [...segs, "$anchor"], "$anchor must match the anchor-name syntax");
+  }
+  if (schema.$dynamicAnchor !== undefined && typeof schema.$dynamicAnchor === "string" && !/^[A-Za-z][A-Za-z0-9:_-]*$/.test(schema.$dynamicAnchor)) {
+    _metaErr(errors, "$dynamicAnchor", [...segs, "$dynamicAnchor"], "$dynamicAnchor must match the anchor-name syntax");
+  }
+  if (schema.$vocabulary !== undefined) {
+    if (!schema.$vocabulary || typeof schema.$vocabulary !== "object" || Array.isArray(schema.$vocabulary)) {
+      _metaErr(errors, "$vocabulary", [...segs, "$vocabulary"], "$vocabulary must be an object");
+    } else {
+      for (const [uri, required] of Object.entries(schema.$vocabulary)) {
+        if (typeof required !== "boolean") {
+          _metaErr(errors, "$vocabulary", [...segs, "$vocabulary", uri], "vocabulary values must be boolean");
+        }
+      }
+    }
+  }
   if (schema.properties !== undefined) {
     if (
       typeof schema.properties !== "object" ||
@@ -741,6 +865,36 @@ function _metaValidate(schema, segs, errors, depth) {
       }
     }
   }
+  for (const k of ["patternProperties", "dependentSchemas"]) {
+    if (schema[k] === undefined) continue;
+    if (typeof schema[k] !== "object" || Array.isArray(schema[k])) {
+      _metaErr(errors, k, [...segs, k], `${k} must be an object`);
+    } else {
+      for (const [name, sub] of Object.entries(schema[k])) {
+        if (k === "patternProperties") {
+          try { new RegExp(name); } catch (e) { _metaErr(errors, k, [...segs, k, name], `invalid regex: ${e.message}`); }
+        }
+        _metaValidate(sub, [...segs, k, name], errors, depth + 1);
+      }
+    }
+  }
+  if (schema.propertyNames !== undefined) {
+    _metaValidate(schema.propertyNames, [...segs, "propertyNames"], errors, depth + 1);
+  }
+  if (schema.dependentRequired !== undefined) {
+    if (typeof schema.dependentRequired !== "object" || Array.isArray(schema.dependentRequired)) {
+      _metaErr(errors, "dependentRequired", [...segs, "dependentRequired"], "dependentRequired must be an object");
+    } else {
+      for (const [key, required] of Object.entries(schema.dependentRequired)) {
+        if (!Array.isArray(required) || required.some((v) => typeof v !== "string")) {
+          _metaErr(errors, "dependentRequired", [...segs, "dependentRequired", key], "dependentRequired values must be arrays of strings");
+        }
+      }
+    }
+  }
+  if (schema.contains !== undefined) {
+    _metaValidate(schema.contains, [...segs, "contains"], errors, depth + 1);
+  }
   if (
     schema.additionalProperties !== undefined &&
     typeof schema.additionalProperties === "object"

package/src/lib/lan-pairing-preflight.js

@@ -21,8 +21,12 @@
 
 import os from "node:os";
 import fs from "node:fs";
-import { execSync } from "node:child_process";
 import dgram from "node:dgram";
+import executionBroker from "./process-execution-broker/index.js";
+
+export const _deps = {
+  execFileSync: (...args) => executionBroker.execFileSync(...args),
+};
 
 const MDNS_PORT = 5353;
 const MDNS_GROUP = "224.0.0.251";
@@ -313,7 +317,14 @@ function which(cmd) {
   try {
     const platform = os.platform();
     const probe = platform === "win32" ? "where" : "which";
-    execSync(`${probe} ${cmd}`, { stdio: "pipe", windowsHide: true });
+    _deps.execFileSync(probe, [cmd], {
+      origin: "lan-pairing:firewall-probe",
+      scope: "network-diagnostics",
+      policy: "allow",
+      shell: false,
+      stdio: "pipe",
+      windowsHide: true,
+    });
     return true;
   } catch (_err) {
     return false;

package/src/lib/lsp/__tests__/lsp-server-registry.test.js

@@ -109,6 +109,24 @@ describe("plugin server registration", () => {
     expect(s).toMatchObject({ id: "zls" });
   });
 
+  it("returns plugin provenance for Broker-enforced servers", () => {
+    registerLanguageServer({
+      languageId: "kotlin",
+      command: "kotlin-lsp",
+      pluginId: "p-kotlin",
+      pluginVersion: "1.2.3",
+      pluginSource: "/plugins/kotlin/.lsp.json",
+    });
+    const isWin = process.platform === "win32";
+    existsFor([path.join("/proj", "node_modules", ".bin", isWin ? "kotlin-lsp.cmd" : "kotlin-lsp")]);
+    expect(resolveServer("kotlin", "/proj")).toMatchObject({
+      origin: "plugin:lsp",
+      pluginId: "p-kotlin",
+      pluginVersion: "1.2.3",
+      pluginSource: "/plugins/kotlin/.lsp.json",
+    });
+  });
+
   it("rejects an incomplete registration", () => {
     expect(() => registerLanguageServer({ languageId: "x" })).toThrow(
       /requires/,

package/src/lib/lsp/lsp-client.js

@@ -16,6 +16,7 @@
 import { spawn as nodeSpawn } from "child_process";
 import { EventEmitter } from "events";
 import { encodeMessage, MessageBuffer } from "./jsonrpc-stream.js";
+import { executionBroker } from "../process-execution-broker/index.js";
 
 const DEFAULT_REQUEST_TIMEOUT_MS = 15_000;
 const DEFAULT_INIT_TIMEOUT_MS = 30_000;
@@ -41,6 +42,10 @@ export class LSPClient extends EventEmitter {
     this.env = opts.env || {};
     this.requestTimeoutMs = opts.requestTimeoutMs || DEFAULT_REQUEST_TIMEOUT_MS;
     this.capabilitiesOverride = opts.capabilities || null;
+    this.origin = opts.origin || null;
+    this.pluginId = opts.pluginId || null;
+    this.pluginVersion = opts.pluginVersion || null;
+    this.pluginSource = opts.pluginSource || null;
 
     this._child = null;
     this._buffer = new MessageBuffer();
@@ -73,13 +78,25 @@ export class LSPClient extends EventEmitter {
     // fix, so buildSpawnCommand rewrites them to an explicit `cmd.exe /d /s /c`
     // invocation with verbatim args — still no shell, still injection-safe.
     const spawnSpec = buildSpawnCommand(this.command, this.args);
-    this._child = _deps.spawn(spawnSpec.file, spawnSpec.args, {
+    const spawnFn = String(this.origin || "").startsWith("plugin:")
+      ? executionBroker.spawn.bind(executionBroker)
+      : _deps.spawn;
+    this._child = spawnFn(spawnSpec.file, spawnSpec.args, {
       cwd: this.rootPath,
       env: { ...process.env, ...this.env },
       stdio: ["pipe", "pipe", "pipe"],
       shell: false,
       windowsHide: true,
       windowsVerbatimArguments: spawnSpec.windowsVerbatimArguments,
+      ...(this.origin
+        ? {
+            origin: this.origin,
+            policy: "allow",
+            pluginId: this.pluginId,
+            pluginVersion: this.pluginVersion,
+            pluginSource: this.pluginSource,
+          }
+        : {}),
     });
 
     this._child.on("error", (err) => {

package/src/lib/lsp/lsp-manager.js

@@ -239,6 +239,10 @@ export class LSPManager {
       command: resolved.command,
       args: resolved.args,
       rootPath: projectRoot,
+      origin: resolved.origin,
+      pluginId: resolved.pluginId,
+      pluginVersion: resolved.pluginVersion,
+      pluginSource: resolved.pluginSource,
     });
     // Collect pushed diagnostics keyed by document, tracking publish count/time
     // so callers can wait for the project to load (first publish) and settle

package/src/lib/lsp/lsp-server-registry.js

@@ -95,6 +95,9 @@ export function registerLanguageServer(def) {
     bins: [def.command],
     argsFor: () => (Array.isArray(def.args) ? def.args : []),
     fromPlugin: true,
+    pluginId: def.pluginId || null,
+    pluginVersion: def.pluginVersion || null,
+    pluginSource: def.pluginSource || null,
   };
   const existing = pluginServers.get(def.languageId) || [];
   // De-dupe by server id so re-registering the same server (e.g. a reload)
@@ -147,6 +150,14 @@ export function resolveServer(languageId, projectRoot) {
           id: def.id,
           command,
           args: def.argsFor(bin),
+          ...(def.fromPlugin
+            ? {
+                origin: "plugin:lsp",
+                pluginId: def.pluginId,
+                pluginVersion: def.pluginVersion,
+                pluginSource: def.pluginSource,
+              }
+            : {}),
         };
       }
     }

package/src/lib/mcp-oauth.js

@@ -25,7 +25,7 @@ import pathDefault from "node:path";
 import { homedir as homedirDefault } from "node:os";
 import crypto from "node:crypto";
 import http from "node:http";
-import { spawn } from "node:child_process";
+import { executionBroker } from "./process-execution-broker/index.js";
 
 export const _deps = {
   fetch: (...a) => globalThis.fetch(...a),
@@ -35,7 +35,13 @@ export const _deps = {
   sha256: (s) => crypto.createHash("sha256").update(s).digest(),
   createServer: (h) => http.createServer(h),
   openBrowser: defaultOpenBrowser,
-  spawn: (...a) => spawn(...a),
+  spawn: (command, args, options) =>
+    executionBroker.spawn(command, args, {
+      ...options,
+      origin: "mcp:oauth-browser",
+      policy: "allow",
+      scope: "oauth",
+    }),
   now: () => Date.now(),
   // Backoff sleep seam (tests override with a no-op so the retry doesn't wait).
   sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),

package/src/lib/npm-invocation.js

@@ -0,0 +1,29 @@
+import path from "node:path";
+
+/**
+ * Resolve npm without asking a shell to interpret the platform shim.
+ *
+ * Windows npm installations expose `npm.cmd`, but Node cannot execute a CMD
+ * shim with `shell:false` (`spawnSync npm.cmd EINVAL`). The shim delegates to
+ * the npm CLI located beside node.exe, so invoke that JavaScript entrypoint
+ * through the current Node executable instead.
+ */
+export function resolveNpmInvocation({
+  platform = process.platform,
+  execPath = process.execPath,
+} = {}) {
+  if (platform !== "win32") {
+    return { command: "npm", prefixArgs: [] };
+  }
+
+  const npmCliPath = path.win32.join(
+    path.win32.dirname(execPath),
+    "node_modules",
+    "npm",
+    "bin",
+    "npm-cli.js",
+  );
+  return { command: execPath, prefixArgs: [npmCliPath] };
+}
+
+export default resolveNpmInvocation;

package/src/lib/packer/pkg-runner.js

@@ -14,8 +14,12 @@
 import fs from "node:fs";
 import path from "node:path";
 import { createRequire } from "node:module";
-import { spawnSync } from "node:child_process";
 import { PackError, EXIT } from "./errors.js";
+import executionBroker from "../process-execution-broker/index.js";
+
+export const _deps = {
+  spawnSync: (...args) => executionBroker.spawnSync(...args),
+};
 
 /**
  * @param {object} ctx
@@ -47,12 +51,19 @@ export function runPkg(ctx) {
   ];
 
   log(`  [pkg] Running: ${pkgBin.runtime} ${args.join(" ")}`);
-  const res = spawnSync(pkgBin.runtime, args, {
+  const res = _deps.spawnSync(pkgBin.runtime, args, {
+    origin: "packer:pkg",
+    scope: "pack",
+    policy: "allow",
+    shell: false,
     cwd: path.dirname(pkgConfigFile),
     stdio: "inherit",
     windowsHide: true,
   });
 
+  if (res.error) {
+    throw new PackError(`Failed to start pkg: ${res.error.message}`, EXIT.PKG);
+  }
   if (res.status !== 0) {
     throw new PackError(
       `pkg exited with code ${res.status}. See output above for details.`,