@xagents_in/unmask 0.1.2 → 0.1.4

package/dist/core/syntax.mjs

@@ -1,6 +1,19 @@
 import { parse } from "acorn";
 import { createHash } from "node:crypto";
 import { validateReport } from "./report.mjs";
+import {
+  BEHAVIOR_LIMITS,
+  javascriptSignal,
+  manifestScriptSpans,
+  destructiveSignals,
+  DESTRUCTIVE_LIMITS,
+  moduleAliases,
+  NETWORK_MODULES,
+  obfuscationSignals,
+  OBFUSCATION_LIMITS,
+  scriptSignals,
+  summaryFor,
+} from "./behavior-signals.mjs";
 
 export const SYNTAX_LIMITS = Object.freeze({
   fileBytes: 2097152,
@@ -79,8 +92,26 @@ function nameOf(node) {
   }
   return "";
 }
-function capability(node) {
+function aliasedName(callee, aliases) {
+  if (callee?.type === "Identifier") return aliases.get(callee.name) ?? "";
+  if (
+    callee?.type === "MemberExpression" &&
+    !callee.computed &&
+    callee.object.type === "Identifier" &&
+    aliases.has(callee.object.name)
+  )
+    return `${aliases.get(callee.object.name)}.${callee.property.name}`;
+  return "";
+}
+function capability(node, aliases) {
   const name = nameOf(node.callee);
+  const aliased = aliases?.size ? aliasedName(node.callee, aliases) : "";
+  if (
+    node.type === "CallExpression" &&
+    aliased &&
+    /^(https?\.(request|get)|net\.connect)$/.test(aliased)
+  )
+    return "network-call";
   if (
     node.type === "CallExpression" &&
     /^(fetch|globalThis.fetch|https?\.(request|get)|net\.connect)$/.test(name)
@@ -144,7 +175,92 @@ export function inspectJavaScript(artifact, source, overrides = {}) {
   const literals = new Map(),
     candidates = [],
     evidence = new Map();
-  let sourceLiteralTruncated = false;
+  let sourceLiteralTruncated = false,
+    syntaxCount = 0;
+  const hookTargets = new Map();
+  const linked = new Map();
+  const link = (path, hooks, from) => {
+    const item = linked.get(path) ?? { hooks: new Set(), from: new Set() };
+    for (const hook of hooks) item.hooks.add(hook);
+    item.from.add(from);
+    if (linked.has(path) || linked.size < BEHAVIOR_LIMITS.linkedScripts)
+      linked.set(path, item);
+  };
+  const behaviorUse = { review: 0, HIGH: 0, perFileRule: new Map() };
+  const admitBehavior = (priority, path, ruleId) => {
+    const key = `${path}\0${ruleId}`;
+    const used = behaviorUse.perFileRule.get(key) || 0;
+    const tier = priority === "HIGH" ? "HIGH" : "review";
+    const cap =
+      tier === "HIGH" ? BEHAVIOR_LIMITS.highCues : BEHAVIOR_LIMITS.reviewCues;
+    if (
+      used >= 0 &&
+      behaviorUse[tier] < cap &&
+      (tier === "HIGH" || used < BEHAVIOR_LIMITS.reviewCuesPerFileRule)
+    ) {
+      behaviorUse[tier]++;
+      behaviorUse.perFileRule.set(key, used + 1);
+      return true;
+    }
+    if (used !== -1) {
+      behaviorUse.perFileRule.set(key, -1);
+      result.annotations.push({
+        type: "behavior-not-inspected",
+        side: "artifact",
+        path,
+        ruleId,
+        reason: "behavior-cue-cap",
+      });
+    }
+    return false;
+  };
+  const manifest = (artifact?.entries || []).find(
+    (entry) => entry.type === "file" && entry.path === "package.json",
+  );
+  let behaviorManifest = { status: "not-assessed", reason: "not-retained" };
+  if (Buffer.isBuffer(manifest?.content))
+    try {
+      const text = new TextDecoder("utf-8", {
+        fatal: true,
+        ignoreBOM: true,
+      }).decode(manifest.content);
+      const positions = offsets(text);
+      const parsed = manifestScriptSpans(text);
+      behaviorManifest = parsed.reason
+        ? { status: parsed.status, reason: parsed.reason }
+        : { status: parsed.status };
+      for (const item of parsed.hooks) {
+        const assessed = scriptSignals(item.script);
+        if (assessed.status !== "assessed")
+          result.annotations.push({
+            type: "behavior-not-inspected",
+            side: "artifact",
+            path: manifest.path,
+            hook: item.hook,
+            reason: assessed.reason,
+          });
+        for (const script of assessed.scripts || [])
+          link(script, [item.hook], `package.json#scripts.${item.hook}`);
+        for (const target of assessed.targets || [])
+          hookTargets.set(target, [
+            ...new Set([...(hookTargets.get(target) || []), item.hook]),
+          ]);
+        for (const { ruleId, priority, ...signal } of assessed.signals)
+          if (admitBehavior(priority, manifest.path, ruleId))
+            candidates.push({
+              behavior: { ruleId, priority, hook: item.hook, ...signal },
+              evidence: evidenceFor(
+                "artifact",
+                artifact,
+                manifest,
+                item,
+                positions,
+              ),
+            });
+      }
+    } catch {
+      behaviorManifest = { status: "not-assessed", reason: "invalid-utf8" };
+    }
   for (const [side, inventory] of [
     ["artifact", artifact],
     ["source", source],
@@ -219,7 +335,35 @@ export function inspectJavaScript(artifact, source, overrides = {}) {
       coverage.files++;
       coverage.bytes += entry.size;
       const positions = offsets(text);
-      for (const node of nodes(ast)) {
+      const all = nodes(ast);
+      const networkAliases =
+        side === "artifact" ? moduleAliases(all, NETWORK_MODULES) : null;
+      if (side === "artifact") {
+        const hooks = hookTargets.get(entry.path);
+        const found = obfuscationSignals(all);
+        if (found.capped) skip("behavior-obfuscation-cap");
+        const destructive = destructiveSignals(all);
+        if (destructive.capped) skip("behavior-destructive-cap");
+        found.signals.push(...destructive.signals);
+        for (const {
+          ruleId,
+          priority,
+          node,
+          related,
+          detail,
+        } of found.signals) {
+          if (admitBehavior(priority, entry.path, ruleId))
+            candidates.push({
+              behavior: { ruleId, priority, ...detail },
+              hooks,
+              evidence: evidenceFor(side, inventory, entry, node, positions),
+              related: related.map((item) =>
+                evidenceFor(side, inventory, entry, item, positions),
+              ),
+            });
+        }
+      }
+      for (const node of all) {
         if (side === "source") {
           if (
             node.type === "Literal" &&
@@ -235,24 +379,128 @@ export function inspectJavaScript(artifact, source, overrides = {}) {
           }
           continue;
         }
-        const kind = capability(node);
-        if (!kind) continue;
-        if (candidates.length >= limits.cues) {
+        const kind = capability(node, networkAliases);
+        const signal = javascriptSignal(node);
+        if (!kind && !signal) continue;
+        if (kind && syntaxCount >= limits.cues) {
           skip("syntax-cue-cap");
           break;
         }
-        candidates.push({
-          kind,
-          evidence: evidenceFor(side, inventory, entry, node, positions),
-          literal:
-            node.arguments?.[0]?.type === "Literal" &&
-            typeof node.arguments[0].value === "string"
-              ? node.arguments[0].value
-              : null,
-        });
+        const hooks = hookTargets.get(entry.path);
+        syntaxCount += kind ? 1 : 0;
+        if (kind)
+          candidates.push({
+            kind,
+            hooks,
+            evidence: evidenceFor(side, inventory, entry, node, positions),
+            literal:
+              node.arguments?.[0]?.type === "Literal" &&
+              typeof node.arguments[0].value === "string"
+                ? node.arguments[0].value
+                : null,
+          });
+        if (signal && admitBehavior("review", entry.path, signal.ruleId)) {
+          const { ruleId, at, ...detail } = signal;
+          candidates.push({
+            behavior: { ruleId, priority: "review", ...detail },
+            hooks,
+            evidence: evidenceFor(
+              side,
+              inventory,
+              entry,
+              at || node,
+              positions,
+            ),
+          });
+        }
       }
     }
   }
+  for (const candidate of candidates)
+    if (
+      candidate.kind === "process-execution" &&
+      candidate.hooks &&
+      candidate.literal !== null
+    )
+      for (const script of scriptSignals(candidate.literal).scripts || [])
+        link(script, candidate.hooks, candidate.evidence.path);
+  for (const [path, { hooks, from }] of linked) {
+    const entry = artifact.entries.find(
+      (item) => item.type === "file" && item.path === path,
+    );
+    const unscanned = (reason) =>
+      result.annotations.push({
+        type: "behavior-not-inspected",
+        side: "artifact",
+        path,
+        reason,
+      });
+    if (!entry) {
+      unscanned("linked-script-missing");
+      continue;
+    }
+    if (!Buffer.isBuffer(entry.content)) {
+      unscanned("not-retained");
+      continue;
+    }
+    if (entry.size > BEHAVIOR_LIMITS.linkedScriptBytes) {
+      unscanned("linked-script-byte-cap");
+      continue;
+    }
+    let text;
+    try {
+      text = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(
+        entry.content,
+      );
+    } catch {
+      unscanned("invalid-utf8");
+      continue;
+    }
+    const assessed = scriptSignals(text, {
+      maxBytes: BEHAVIOR_LIMITS.linkedScriptBytes,
+      maxTokens: BEHAVIOR_LIMITS.linkedScriptTokens,
+    });
+    if (assessed.status !== "assessed") {
+      unscanned(assessed.reason);
+      continue;
+    }
+    const positions = offsets(text);
+    const lines = [];
+    for (let start = 0; start < text.length;) {
+      const stop = text.indexOf("\n", start);
+      const end = stop === -1 ? text.length : stop;
+      lines.push({ start, end, lower: text.slice(start, end).toLowerCase() });
+      start = end + 1;
+    }
+    for (const { ruleId, priority, ...signal } of assessed.signals) {
+      const words = [
+        ...(signal.tools || []),
+        ...(signal.file ? [signal.file.toLowerCase()] : []),
+        ...(signal.paths || []),
+        ...(signal.variables || []).map((name) => name.toLowerCase()),
+        ...(signal.commands || []).map((command) => command.split(" ")[0]),
+      ];
+      const cited = lines
+        .filter((line) => words.some((word) => line.lower.includes(word)))
+        .slice(0, 3);
+      if (!cited.length || !admitBehavior(priority, path, ruleId)) continue;
+      const [first, ...rest] = cited.map((line) =>
+        evidenceFor("artifact", artifact, entry, line, positions),
+      );
+      candidates.push({
+        behavior: {
+          ruleId,
+          priority,
+          script: path,
+          linkedFrom: [...from].sort(),
+          ...signal,
+        },
+        hooks: [...hooks].sort(),
+        evidence: first,
+        related: rest,
+      });
+    }
+  }
   const stem = (value) => value.replace(/\.[cm]?[jt]sx?$/, "");
   const unknownSource = new Set(
     result.annotations
@@ -265,6 +513,27 @@ export function inspectJavaScript(artifact, source, overrides = {}) {
   for (const candidate of candidates) {
     const ids = [candidate.evidence.id];
     evidence.set(candidate.evidence.id, candidate.evidence);
+    const hookTarget = candidate.hooks
+      ? { installHookTarget: candidate.hooks }
+      : {};
+    for (const item of candidate.related || []) {
+      evidence.set(item.id, item);
+      if (!ids.includes(item.id)) ids.push(item.id);
+    }
+    if (candidate.behavior) {
+      const { ruleId, priority, ...signal } = candidate.behavior;
+      result.cues.push({
+        module: "behavior",
+        ruleId,
+        priority,
+        summary: summaryFor(ruleId),
+        confidence: "suspicion-not-proof",
+        signal,
+        ...hookTarget,
+        evidenceIds: ids,
+      });
+      continue;
+    }
     const match = candidate.literal !== null && literals.get(candidate.literal);
     if (match) {
       evidence.set(match.id, match);
@@ -291,10 +560,22 @@ export function inspectJavaScript(artifact, source, overrides = {}) {
                 ? "not-assessed"
                 : "not-found-in-inspected-source"
               : "source-unavailable",
+      ...hookTarget,
       evidenceIds: ids,
     });
   }
   result.evidence = [...evidence.values()];
+  result.annotations.push({
+    type: "behavior-scope",
+    manifest: behaviorManifest,
+    limits: {
+      ...BEHAVIOR_LIMITS,
+      obfuscation: { ...OBFUSCATION_LIMITS },
+      destructive: { ...DESTRUCTIVE_LIMITS },
+    },
+    limitation:
+      "Behavior cues are static text and syntax suspicions, not proof of execution or intent. Install hooks and package code were not run; aliases, computed names and runtime-constructed paths are not resolved.",
+  });
   result.annotations.push({
     type: "syntax-scope",
     parser: "acorn@8.19.0",