nexus-agents 8.60.0 → 8.60.2

package/dist/{chunk-GYOPH7LC.js → chunk-3UAEJN4N.js}

@@ -1,9 +1,6 @@
 import {
   VERSION
-} from "./chunk-UEUHEBNI.js";
-import {
-  emitClawGuardViolation
-} from "./chunk-JZ7MTCXL.js";
+} from "./chunk-7JA62DNM.js";
 import {
   CACHE_TIMEOUTS,
   MCP_TIMEOUTS,
@@ -1474,270 +1471,6 @@ var TimeoutGuard = class {
   }
 };
 
-// src/security/access-constraint-deriver/denylist.ts
-var UNBYPASSABLE_PATH_PATTERNS = [
-  // Environment files
-  ".env",
-  ".env.*",
-  "**/.env",
-  "**/.env.*",
-  // SSH credentials
-  "~/.ssh/**",
-  "**/ssh/id_*",
-  "**/*_rsa",
-  "**/*_ed25519",
-  "**/*.pem",
-  // Cloud credentials
-  "~/.aws/**",
-  "~/.azure/**",
-  "~/.gcp/**",
-  "~/.config/gcloud/**",
-  "~/.kube/config",
-  // Unix secret files
-  "/etc/shadow",
-  "/etc/sudoers",
-  "/etc/sudoers.d/**",
-  // Common secret file patterns
-  "**/secrets.*",
-  "**/credentials.*",
-  "**/private_key.*",
-  "**/id_rsa*"
-];
-var UNBYPASSABLE_TOOL_NAMES = [
-  // Destructive git operations
-  "git_push_force",
-  "git_reset_hard",
-  "git_branch_delete_force",
-  "git_clean_force",
-  // Destructive filesystem
-  "rm_recursive_force",
-  "chmod_recursive",
-  // Identity / auth mutations
-  "ssh_add_key",
-  "gpg_add_key",
-  "npm_publish_force",
-  // Remote destruction
-  "github_repo_delete",
-  "github_org_transfer",
-  "aws_account_close"
-];
-function compileGlobToRegex(pattern) {
-  const pat = pattern.toLowerCase();
-  const escaped = pat.replace(/[\\.+^$()|[\]{}]/g, "\\$&").replace(/\*\*/g, "__DOUBLESTAR__").replace(/\*/g, "[^/]*").replace(/__DOUBLESTAR__/g, ".*");
-  const anchored = escaped.startsWith("~/") ? `(^|/)${escaped.slice(2)}$` : escaped.startsWith("/") ? `^${escaped}$` : `(^|/)${escaped}$`;
-  return new RegExp(anchored);
-}
-var COMPILED_PATH_PATTERNS = UNBYPASSABLE_PATH_PATTERNS.map((pattern) => ({
-  pattern,
-  regex: compileGlobToRegex(pattern)
-}));
-function isPathDenied(path) {
-  const normalized = path.toLowerCase();
-  return COMPILED_PATH_PATTERNS.some((c) => c.regex.test(normalized));
-}
-function isToolDenied(toolName) {
-  return UNBYPASSABLE_TOOL_NAMES.includes(toolName);
-}
-
-// src/security/access-constraint-deriver/tool-risk.ts
-var READ_ONLY_TOOLS2 = /* @__PURE__ */ new Set([
-  // Discovery / listing
-  "list_experts",
-  "list_workflows",
-  // Research reads
-  "research_query",
-  "research_analyze",
-  "research_catalog_review",
-  "research_synthesize",
-  // Memory reads
-  "memory_query",
-  "memory_stats",
-  // Observability
-  "weather_report",
-  "query_trace",
-  "query_task_state",
-  // Async-mode result polling (#3042 / epic #2631)
-  "get_job_result",
-  // Async-mode job discovery (#3046 / epic #2631 Stage 5)
-  "list_jobs",
-  // Codebase intelligence (read-only over local files)
-  "search_codebase",
-  "extract_symbols",
-  // Repo analysis (read-only)
-  "repo_analyze",
-  "repo_security_plan",
-  // Routing recommendation (no side effects — returns recommendation)
-  "delegate_to_model",
-  // Registry import (returns a draft template — does not write)
-  "registry_import"
-]);
-function isRiskyTool(toolName) {
-  return !READ_ONLY_TOOLS2.has(toolName);
-}
-
-// src/security/access-constraint-deriver/enforcer.ts
-function checkAccess(toolName, policy, args) {
-  if (isToolDenied(toolName)) {
-    return {
-      decision: "deny",
-      reason: `tool "${toolName}" is on the unbypassable deny-tool list`,
-      matchedRule: "unbypassable:tool"
-    };
-  }
-  if (typeof args?.path === "string" && args.path.length > 0 && isPathDenied(args.path)) {
-    return {
-      decision: "deny",
-      reason: `path "${args.path}" is on the unbypassable deny-path list`,
-      matchedRule: "unbypassable:path"
-    };
-  }
-  if (policy.allowedTools === "*") return { decision: "allow" };
-  if (policy.allowedTools.length === 0) {
-    const refuseVerb = policy.refuseVerbMatched;
-    return {
-      decision: "unmeasured",
-      reason: `allowlist arm did not run for tool "${toolName}": the derived policy (source "${policy.source}", mode "${policy.mode}") carries an empty allowedTools, and no producer emits tool names (#5022)${refuseVerbNote(refuseVerb)}`,
-      ...refuseVerb !== void 0 && { refuseVerbMatched: refuseVerb }
-    };
-  }
-  if (policy.allowedTools.includes(toolName)) return { decision: "allow" };
-  return decideOnViolation(toolName, policy.mode);
-}
-function refuseVerbNote(refuseVerb) {
-  if (refuseVerb === void 0) return "";
-  return `; the objective matched the destructive verb "${refuseVerb}", which this verdict does NOT deny (#5895)`;
-}
-function decideOnViolation(toolName, mode) {
-  if (mode === "audit") {
-    return {
-      decision: "log-and-allow",
-      warning: `tool "${toolName}" not in derived policy (audit mode)`
-    };
-  }
-  if (mode === "confirm_risky") {
-    if (!isRiskyTool(toolName)) {
-      return {
-        decision: "log-and-allow",
-        warning: `tool "${toolName}" not in derived policy (confirm_risky mode, read-only \u2014 would have required human approval, allowed because read-only)`
-      };
-    }
-    return {
-      decision: "deny",
-      reason: `tool "${toolName}" not in derived policy (confirm_risky mode, risky \u2014 would have required human approval; denied for now, add to allowedTools or run in audit mode to allow)`,
-      matchedRule: "allowedTools:confirm_risky"
-    };
-  }
-  return {
-    decision: "deny",
-    reason: `tool "${toolName}" not in derived policy`,
-    matchedRule: "allowedTools"
-  };
-}
-
-// src/security/access-constraint-deriver/mcp-guard.ts
-import { AsyncLocalStorage as AsyncLocalStorage3 } from "node:async_hooks";
-var accessPolicyStorage = new AsyncLocalStorage3();
-var auditTrailStorage = new AsyncLocalStorage3();
-var MAX_WARNING_LEN = 500;
-function withAuditTrail(trail, fn) {
-  return auditTrailStorage.run(trail, fn);
-}
-function getActiveAuditTrail() {
-  return auditTrailStorage.getStore();
-}
-function recordAuditModeViolation(input) {
-  const trail = getActiveAuditTrail();
-  if (trail === void 0) return;
-  try {
-    emitClawGuardViolation(trail, {
-      toolName: input.toolName,
-      warning: input.warning.slice(0, MAX_WARNING_LEN),
-      policySource: input.policySource,
-      mode: input.mode,
-      requestId: input.requestId,
-      // Outside `warning`, so the 500-char cap above cannot eat it.
-      ...input.matchedRule !== void 0 && { matchedRule: input.matchedRule }
-    });
-  } catch {
-  }
-}
-function withAccessPolicy(policy, fn) {
-  return accessPolicyStorage.run(policy, fn);
-}
-function getActivePolicy() {
-  return accessPolicyStorage.getStore();
-}
-
-// src/security/access-constraint-deriver/chain-adapter.ts
-function toGuardArgs(args) {
-  if (typeof args !== "object" || args === null) return void 0;
-  const path = args["path"];
-  return typeof path === "string" && path.length > 0 ? { path } : void 0;
-}
-function createAccessPolicyChainMiddleware(toolName) {
-  return async (args, ctx, next) => {
-    const policy = getActivePolicy();
-    if (policy === void 0 || policy.mode === "off") {
-      return next(args, ctx);
-    }
-    const decision = checkAccess(toolName, policy, toGuardArgs(args));
-    if (decision.decision === "allow") {
-      return next(args, ctx);
-    }
-    if (decision.decision === "unmeasured") {
-      ctx.logger.info("access-policy: allowlist unmeasured", {
-        tool: toolName,
-        reason: decision.reason,
-        policySource: policy.source,
-        mode: policy.mode,
-        requestId: ctx.requestContext.requestId,
-        // #5895: a stable field, so a future counter keys on this rather than
-        // parsing `reason`. Absent unless the objective matched a refuse verb.
-        ...decision.refuseVerbMatched !== void 0 && {
-          refuseVerbMatched: decision.refuseVerbMatched
-        }
-      });
-      return next(args, ctx);
-    }
-    if (decision.decision === "log-and-allow") {
-      ctx.logger.warn("access-policy: audit violation", {
-        tool: toolName,
-        warning: decision.warning,
-        policySource: policy.source,
-        requestId: ctx.requestContext.requestId
-      });
-      recordAuditModeViolation({
-        toolName,
-        warning: decision.warning,
-        policySource: policy.source,
-        mode: policy.mode,
-        requestId: ctx.requestContext.requestId
-      });
-      return next(args, ctx);
-    }
-    reportAdvisoryViolation(toolName, decision, policy, ctx);
-    return next(args, ctx);
-  };
-}
-function reportAdvisoryViolation(toolName, decision, policy, ctx) {
-  ctx.logger.warn("access-policy: advisory violation", {
-    tool: toolName,
-    reason: decision.reason,
-    matchedRule: decision.matchedRule,
-    policySource: policy.source,
-    mode: policy.mode,
-    requestId: ctx.requestContext.requestId
-  });
-  recordAuditModeViolation({
-    toolName,
-    warning: `[advisory: would have denied] ${decision.reason}`,
-    policySource: policy.source,
-    mode: policy.mode,
-    requestId: ctx.requestContext.requestId,
-    matchedRule: decision.matchedRule
-  });
-}
-
 // src/mcp/middleware/middleware-chain.ts
 function errorResult(category, message, requestId) {
   return toolStructuredError({
@@ -1863,57 +1596,61 @@ function composeMiddleware(middlewares) {
     return dispatch(0, args);
   };
 }
-function addAuditMiddleware(middlewares, skip) {
+function addAuditMiddleware(stages, skip) {
   if (skip.audit !== true) {
-    middlewares.push(createAuditMiddleware());
+    stages.push({ name: "audit", middleware: createAuditMiddleware() });
   }
 }
-function addRateLimitMiddleware(middlewares, config, skip) {
+function addRateLimitMiddleware(stages, config, skip) {
   if (skip.rateLimit !== true && config.rateLimiter !== void 0) {
     const limiter = config.rateLimiter instanceof RateLimiter ? config.rateLimiter : new RateLimiter(config.rateLimiter);
-    middlewares.push(createRateLimitMiddleware(limiter));
+    stages.push({ name: "rateLimit", middleware: createRateLimitMiddleware(limiter) });
   }
 }
-function addValidationMiddleware(middlewares, config, skip) {
+function addValidationMiddleware(stages, config, skip) {
   if (skip.validation !== true && config.schema !== void 0) {
-    middlewares.push(createValidationMiddleware(config.schema));
+    stages.push({ name: "validation", middleware: createValidationMiddleware(config.schema) });
   }
 }
-function addPolicyMiddleware(middlewares, config, skip) {
+function addPolicyMiddleware(stages, config, skip) {
   if (skip.policy !== true && config.policyFirewall !== void 0) {
     const mode = config.executionMode ?? "read-only";
-    middlewares.push(
-      createPolicyMiddleware(config.policyFirewall, config.toolName, mode, config.allowedPaths)
-    );
+    stages.push({
+      name: "policy",
+      middleware: createPolicyMiddleware(
+        config.policyFirewall,
+        config.toolName,
+        mode,
+        config.allowedPaths
+      )
+    });
   }
 }
-function addTimeoutMiddleware(middlewares, config, skip) {
+function addTimeoutMiddleware(stages, config, skip) {
   if (skip.timeout !== true && config.timeout !== void 0) {
     const guard = new TimeoutGuard(config.timeout);
-    middlewares.push(createTimeoutMiddleware(guard, config.toolName));
-  }
-}
-function addAccessPolicyMiddleware(middlewares, config, skip) {
-  if (skip.accessPolicy !== true) {
-    middlewares.push(createAccessPolicyChainMiddleware(config.toolName));
+    stages.push({ name: "timeout", middleware: createTimeoutMiddleware(guard, config.toolName) });
   }
 }
 function buildMiddlewareStack(config) {
   const skip = config.skip ?? {};
-  const middlewares = [];
-  middlewares.push(createMetricsMiddleware());
-  addAuditMiddleware(middlewares, skip);
-  addRateLimitMiddleware(middlewares, config, skip);
-  addValidationMiddleware(middlewares, config, skip);
-  addPolicyMiddleware(middlewares, config, skip);
-  addAccessPolicyMiddleware(middlewares, config, skip);
-  addTimeoutMiddleware(middlewares, config, skip);
-  return middlewares;
+  const stages = [];
+  stages.push({ name: "metrics", middleware: createMetricsMiddleware() });
+  addAuditMiddleware(stages, skip);
+  addRateLimitMiddleware(stages, config, skip);
+  addValidationMiddleware(stages, config, skip);
+  addPolicyMiddleware(stages, config, skip);
+  addTimeoutMiddleware(stages, config, skip);
+  return stages;
 }
 function createMiddlewareChain(config) {
   const logger = config.logger ?? createLogger({ tool: config.toolName });
-  const middlewares = buildMiddlewareStack(config);
-  const composed = composeMiddleware(middlewares);
+  const stages = buildMiddlewareStack(config);
+  logger.debug("Middleware chain built", {
+    toolName: config.toolName,
+    stages: stages.map((stage) => stage.name)
+  });
+  const composed = composeMiddleware(stages.map((stage) => stage.middleware));
   return (handler) => {
     return async (args) => {
       const requestContext = createRequestContext({ toolName: config.toolName });
@@ -2355,8 +2092,6 @@ export {
   NOOP_NOTIFIER,
   abortSignalStorage,
   withProgressHeartbeat,
-  withAuditTrail,
-  withAccessPolicy,
   getToolTimeout,
   wrapToolWithTimeout,
   toSdkCallback,
@@ -2380,4 +2115,4 @@ export {
   DEFAULT_CONSENSUS_CONFIG,
   ConsensusMetricsSchema
 };
-//# sourceMappingURL=chunk-GYOPH7LC.js.map
+//# sourceMappingURL=chunk-3UAEJN4N.js.map