fullcourtdefense-cli 1.34.11 → 1.34.14

package/dist/actionPolicyEngine.js

@@ -5738,6 +5738,14 @@ function parse3(input, options) {
 }
 
 // src/actionPolicyEngine.ts
+function isFirestoreQueryUrl(target) {
+  try {
+    const url = new URL(target);
+    return url.origin === "https://firestore.googleapis.com" && !url.username && !url.password && !url.search && !url.hash && /^\/v1\/projects\/[^/]+\/databases\/[^/]+\/documents(?:\/[^/]+)*:runQuery$/.test(url.pathname);
+  } catch {
+    return false;
+  }
+}
 function provenJavaScriptReadUrls(code) {
   if (code.length > 32768) return [];
   const literal2 = (value) => ({ kind: "literal", value });
@@ -5758,6 +5766,8 @@ function provenJavaScriptReadUrls(code) {
   const readProperty = (value, key) => {
     if (["constructor", "__proto__", "prototype"].includes(key)) return fail();
     if (value.kind === "object") return value.fields.get(key) || literal2(void 0);
+    if (value.kind === "array" && key === "map") return { kind: "arrayMap", items: value.items };
+    if (value.kind === "promise" && key === "catch") return callable("promise.catch");
     if (value.kind === "response") return ["json", "text"].includes(key) ? callable(`response.${key}`) : { kind: "data" };
     if (value.kind === "credential" && key === "trim") return callable("credential.trim");
     if (value.kind === "string" || value.kind === "literal" && typeof value.value === "string") {
@@ -5822,24 +5832,97 @@ function provenJavaScriptReadUrls(code) {
         const left = ev(node.left);
         const right = ev(node.right);
         if (node.operator !== "+") return fail();
-        if (left.kind === "literal" && right.kind === "literal" && typeof left.value === "string" && typeof right.value === "string") return literal2(left.value + right.value);
+        if (left.kind === "literal" && right.kind === "literal" && typeof left.value === "string" && typeof right.value === "string") {
+          if (left.value.length + right.value.length > 32768) return fail();
+          return literal2(left.value + right.value);
+        }
         if (left.kind === "literal" && left.value === "Bearer " && right.kind === "credential") return { kind: "authorization" };
         return fail();
       }
       case "ArrowFunctionExpression":
       case "FunctionExpression":
-        if (node.params.length || node.generator) return fail();
+        if (node.params.some((param) => param.type !== "Identifier") || node.generator) return fail();
         return { kind: "function", node, env: new Map(env) };
+      case "ForOfStatement": {
+        const items = ev(node.right);
+        if (node.await || items.kind !== "array" || items.items.length > 100 || node.left.type !== "VariableDeclaration" || node.left.kind !== "const" || node.left.declarations.length !== 1) return fail();
+        for (const item of items.items) {
+          const scope = new Map(env);
+          const id = node.left.declarations[0].id;
+          if (id.type === "Identifier") scope.set(id.name, item);
+          else if (id.type === "ArrayPattern" && item.kind === "array" && id.elements.length === item.items.length) {
+            id.elements.forEach((element, index) => {
+              if (element?.type !== "Identifier") fail();
+              scope.set(element.name, item.items[index]);
+            });
+          } else return fail();
+          evaluate(node.body, scope, depth + 1);
+        }
+        return literal2(void 0);
+      }
+      case "AssignmentExpression": {
+        if (node.operator !== "=" || node.left.type !== "MemberExpression" || node.left.computed || node.left.object.type !== "Identifier" || node.left.object.name !== "process" || env.has("process") || node.left.property.name !== "exitCode" || ev(node.right).kind !== "literal" || node.right.type !== "Literal" || node.right.value !== 1) return fail();
+        return literal2(void 0);
+      }
+      case "NewExpression": {
+        const constructor = ev(node.callee);
+        if (constructor.kind !== "call" || constructor.name !== "GoogleAuth" || node.arguments.length !== 1) return fail();
+        const options = ev(node.arguments[0]);
+        if (options.kind !== "object" || options.fields.size !== 1) return fail();
+        const scopes = options.fields.get("scopes");
+        if (scopes?.kind !== "array" || scopes.items.length !== 1 || string(scopes.items[0]) !== "https://www.googleapis.com/auth/datastore") return fail();
+        return object([["getClient", callable("google.getClient")]]);
+      }
       case "ReturnStatement":
         return node.argument ? ev(node.argument) : literal2(void 0);
       case "CallExpression": {
         const callee = ev(node.callee);
         const args = node.arguments.map(ev);
         if (callee.kind === "function") {
-          if (args.length) return fail();
-          return evaluate(callee.node.body, new Map(callee.env), depth + 1);
+          if (args.length !== callee.node.params.length) return fail();
+          const scope = new Map(callee.env);
+          args.forEach((value, index) => scope.set(callee.node.params[index].name, value));
+          const result = evaluate(callee.node.body, scope, depth + 1);
+          return callee.node.async ? { kind: "promise" } : result;
+        }
+        if (callee.kind === "arrayMap") {
+          if (args.length !== 1 || args[0].kind !== "function" || args[0].node.params.length !== 1 || args[0].node.async) return fail();
+          const fn = args[0];
+          return { kind: "array", items: callee.items.map((item) => {
+            const scope = new Map(fn.env);
+            scope.set(fn.node.params[0].name, item);
+            return evaluate(fn.node.body, scope, depth + 1);
+          }) };
         }
         if (callee.kind !== "call") return fail();
+        if (callee.name === "google.getClient") {
+          if (args.length) return fail();
+          return object([["request", callable("google.request")]]);
+        }
+        if (callee.name === "google.request") {
+          if (args.length !== 1 || args[0].kind !== "object") return fail();
+          const fields = args[0].fields;
+          if ([...fields.keys()].some((key) => !["url", "method", "data"].includes(key))) return fail();
+          const target = string(fields.get("url") || fail());
+          if (!isFirestoreQueryUrl(target) || string(fields.get("method") || fail()).toUpperCase() !== "POST") return fail();
+          const body = fields.get("data");
+          const passive = (value) => {
+            if (--budget < 0) return false;
+            if (value.kind === "literal") return true;
+            if (value.kind === "object") return [...value.fields.values()].every(passive);
+            return value.kind === "array" && value.items.every(passive);
+          };
+          if (body?.kind !== "object" || !body.fields.has("structuredQuery") || [...body.fields.keys()].some((key) => !["structuredQuery", "readTime", "transaction"].includes(key)) || !passive(body)) return fail();
+          urls.push(target);
+          return { kind: "data" };
+        }
+        if (callee.name === "promise.catch") {
+          if (args.length !== 1 || args[0].kind !== "function" || args[0].node.params.length !== 1) return fail();
+          const scope = new Map(args[0].env);
+          scope.set(args[0].node.params[0].name, { kind: "data" });
+          evaluate(args[0].node.body, scope, depth + 1);
+          return { kind: "data" };
+        }
         if (callee.name === "fetch") {
           if (args.length < 1 || args.length > 2) return fail();
           const target = string(args[0]);
@@ -5866,6 +5949,7 @@ function provenJavaScriptReadUrls(code) {
           return { kind: "response" };
         }
         if (callee.name === "require") {
+          if (args.length === 1 && string(args[0]) === "google-auth-library") return object([["GoogleAuth", callable("GoogleAuth")]]);
           if (args.length !== 1 || !["node:child_process", "child_process"].includes(string(args[0]))) return fail();
           return object([["execFileSync", callable("execFileSync")]]);
         }
@@ -5888,7 +5972,7 @@ function provenJavaScriptReadUrls(code) {
           if (args.length !== 1 || !jsonSafe(args[0])) return fail();
           return { kind: "string" };
         }
-        if (callee.name === "console.log") return literal2(void 0);
+        if (callee.name === "console.log" || callee.name === "console.error") return literal2(void 0);
         if (callee.name === "string.trim") {
           if (args.length) return fail();
           return { kind: "string" };
@@ -5913,14 +5997,14 @@ function provenJavaScriptReadUrls(code) {
       ["fetch", callable("fetch")],
       ["require", callable("require")],
       ["JSON", object([["stringify", callable("JSON.stringify")]])],
-      ["console", object([["log", callable("console.log")]])]
+      ["console", object([["log", callable("console.log")], ["error", callable("console.error")]])]
     ]));
     return urls;
   } catch {
     return [];
   }
 }
-function provenInlineJavaScriptRead(command, detectedUrl) {
+function provenInlineJavaScriptReadUrls(command) {
   const urls = [];
   for (const segment of splitShellSegments(command)) {
     const here = segment.match(/^\s*@'\r?\n([\s\S]*?)\r?\n'@\s*\|\s*node(?:\.exe)?(?:\s+-)?\s*$/i);
@@ -5928,14 +6012,197 @@ function provenInlineJavaScriptRead(command, detectedUrl) {
     const code = here?.[1] ?? inline?.[1];
     if (code !== void 0) {
       const proven = provenJavaScriptReadUrls(code);
-      if (!proven.length) return false;
+      if (!proven.length) return [];
       urls.push(...proven);
     } else {
       const lead = shellSegmentLead(segment);
-      if (!(SHELL_READ_PROGRAMS.has(lead) || ["git", "gh", "cd", "set-location"].includes(lead)) || classifyShellCommandOperation(segment) !== "read" || /https?:\/\//i.test(segment)) return false;
+      if (!(SHELL_READ_PROGRAMS.has(lead) || ["git", "gh", "cd", "set-location"].includes(lead)) || classifyShellCommandOperation(segment) !== "read" || /https?:\/\//i.test(segment)) return [];
+    }
+  }
+  return urls;
+}
+function provenPowerShellQueryUrls(command) {
+  if (command.length > 32768) return [];
+  const prefix = /^\s*(?:git\s+status(?:\s+--short)?(?:\s+--branch)?|(?:cd|Set-Location)\s+(?:[A-Za-z]:[\\/][A-Za-z0-9_./\\-]+|'[A-Za-z]:[\\/][A-Za-z0-9_ ./\\-]+'))\s*(?:&&|;)\s*/i;
+  for (let count = 0; count < 8 && prefix.test(command); count++) command = command.replace(prefix, "");
+  const credential = Object.freeze({ credential: 1 });
+  const authorization = Object.freeze({ authorization: 1 });
+  const urls = [];
+  const env = /* @__PURE__ */ new Map();
+  const tokens = [];
+  const fail = () => {
+    throw new Error("Unsupported PowerShell query");
+  };
+  const lexer = /[ \t]+|\r?\n|@\{|@\(|'(?:[^']|'')*'|"[^"`]*"|\$[A-Za-z_][A-Za-z0-9_]*|-[A-Za-z]+|[A-Za-z_][A-Za-z0-9_-]*|\d+|[{}();=+|,]/gy;
+  let offset2 = 0;
+  let budget = 8e3;
+  let pos = 0;
+  const take = () => {
+    if (--budget < 0 || pos >= tokens.length) return fail();
+    return tokens[pos++];
+  };
+  const peek = () => tokens[pos];
+  const expect = (token) => {
+    if (take().toLowerCase() !== token.toLowerCase()) fail();
+  };
+  const separators = () => {
+    while (peek() === ";") take();
+  };
+  const passive = (value) => {
+    if (--budget < 0 || value === credential || value === authorization) return false;
+    if (typeof value !== "object") return true;
+    return Object.values(value).every(passive);
+  };
+  const expression = () => {
+    const token = take();
+    let value;
+    if (token.startsWith("'")) value = token.slice(1, -1).replace(/''/g, "'");
+    else if (token.startsWith('"')) {
+      const text = token.slice(1, -1);
+      const bearer = text.match(/^Bearer (\$[A-Za-z_][A-Za-z0-9_]*)$/);
+      if (bearer && env.get(bearer[1].toLowerCase()) === credential) value = authorization;
+      else {
+        if (/[$`]/.test(text)) return fail();
+        value = text;
+      }
+    } else if (token.startsWith("$")) value = env.get(token.toLowerCase()) ?? fail();
+    else if (/^\d+$/.test(token)) value = Number(token);
+    else if (token === "(") {
+      value = expression();
+      expect(")");
+    } else if (token === "@(") {
+      const items = [];
+      separators();
+      while (peek() !== ")") {
+        items.push(expression());
+        separators();
+        if (peek() !== ")") expect(",");
+      }
+      expect(")");
+      value = items;
+    } else if (token === "@{") {
+      const fields = /* @__PURE__ */ Object.create(null);
+      separators();
+      while (peek() !== "}") {
+        const key = take();
+        if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key) || Object.hasOwn(fields, key)) return fail();
+        expect("=");
+        fields[key] = expression();
+        if (peek() !== "}") expect(";");
+        separators();
+      }
+      expect("}");
+      value = fields;
+    } else if (token.toLowerCase() === "if") {
+      expect("(");
+      const left = expression();
+      expect("-eq");
+      const right = expression();
+      expect(")");
+      if (typeof left === "object" || typeof right === "object") return fail();
+      expect("{");
+      const yes = expression();
+      expect("}");
+      expect("else");
+      expect("{");
+      const no = expression();
+      expect("}");
+      value = left === right ? yes : no;
+    } else if (token.toLowerCase() === "gcloud") {
+      expect("auth");
+      expect("print-access-token");
+      value = credential;
+    } else return fail();
+    while (peek() === "+") {
+      take();
+      const right = expression();
+      if (typeof value !== "string" || typeof right !== "string" || value.length + right.length > 32768) return fail();
+      value += right;
+    }
+    if (peek() === "|") {
+      take();
+      expect("ConvertTo-Json");
+      expect("-Depth");
+      const depth = take();
+      if (!/^\d+$/.test(depth) || Number(depth) > 100 || !passive(value)) return fail();
+    }
+    return value;
+  };
+  const statement = () => {
+    if (peek()?.startsWith("$")) {
+      const name = take().toLowerCase();
+      expect("=");
+      if (["$env", "$psdefaultparametervalues", "$executioncontext", "$erroractionpreference", "$home", "$profile"].includes(name)) return fail();
+      env.set(name, expression());
+      return;
+    }
+    if (peek()?.toLowerCase() === "foreach") {
+      take();
+      expect("(");
+      const name = take().toLowerCase();
+      if (!/^\$[a-z_][a-z0-9_]*$/.test(name)) return fail();
+      expect("in");
+      const items = expression();
+      expect(")");
+      expect("{");
+      if (!Array.isArray(items) || !items.length || items.length > 100) return fail();
+      const start = pos;
+      for (const item of items) {
+        env.set(name, item);
+        pos = start;
+        separators();
+        while (peek() !== "}") {
+          statement();
+          if (peek() !== "}") expect(";");
+          separators();
+        }
+        expect("}");
+      }
+      return;
+    }
+    expect("Invoke-RestMethod");
+    const options = /* @__PURE__ */ new Map();
+    while (peek()?.startsWith("-")) {
+      const flag = take().toLowerCase();
+      if (options.has(flag)) return fail();
+      options.set(flag, flag === "-method" ? take() : expression());
+    }
+    if ([...options.keys()].some((key) => !["-method", "-uri", "-headers", "-contenttype", "-body"].includes(key))) return fail();
+    const target = options.get("-uri");
+    if (typeof target !== "string") return fail();
+    if (!isFirestoreQueryUrl(target) || String(options.get("-method")).toUpperCase() !== "POST" || options.get("-contenttype") !== "application/json") return fail();
+    const headers = options.get("-headers");
+    const body = options.get("-body");
+    if (!headers || typeof headers !== "object" || Array.isArray(headers) || Object.keys(headers).length !== 1 || headers.Authorization !== authorization) return fail();
+    if (!body || typeof body !== "object" || Array.isArray(body) || !Object.hasOwn(body, "structuredQuery") || Object.keys(body).some((key) => !["structuredQuery", "transaction", "readTime"].includes(key)) || !passive(body)) return fail();
+    urls.push(target);
+    if (peek() === "|") {
+      take();
+      expect("ConvertTo-Json");
+      expect("-Depth");
+      if (!/^\d+$/.test(take())) fail();
+    }
+  };
+  try {
+    while (offset2 < command.length) {
+      lexer.lastIndex = offset2;
+      const match = lexer.exec(command);
+      if (!match) return [];
+      offset2 = lexer.lastIndex;
+      const token = match[0];
+      if (/^[ \t]+$/.test(token)) continue;
+      tokens.push(/\r?\n/.test(token) && token.length <= 2 ? ";" : token);
+    }
+    separators();
+    while (pos < tokens.length) {
+      statement();
+      if (pos < tokens.length) expect(";");
+      separators();
     }
+    return urls;
+  } catch {
+    return [];
   }
-  return urls.includes(detectedUrl);
 }
 function approvalExceptionError(rule) {
   const ids = rule.approval?.replacesPolicyIds;
@@ -6445,6 +6712,7 @@ var OPERATION_MATCH_SKIP_FIELDS = /* @__PURE__ */ new Set([
   "destination.domain",
   "destination.host",
   "destination.type",
+  "destination.repository",
   "destinationHost",
   "host",
   "hostname",
@@ -6458,7 +6726,9 @@ var OPERATION_MATCH_SKIP_FIELDS = /* @__PURE__ */ new Set([
 function buildOperationMatchText(_toolName, context) {
   const parts = [];
   for (const [key, value] of Object.entries(context)) {
-    if (OPERATION_MATCH_SKIP_FIELDS.has(key)) continue;
+    const fieldWords = key.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase().split(/[_.-]/);
+    const identifierField = /^(?:id|ids|uuid|uuids|guid|guids)$/.test(fieldWords[fieldWords.length - 1]);
+    if (OPERATION_MATCH_SKIP_FIELDS.has(key) || identifierField) continue;
     if (typeof value !== "string" || value.length === 0 || value.length > 2e3) continue;
     const text = COMMAND_LINE_FIELDS.has(key) ? shellVerbWords(value) : value;
     parts.push(`${key} ${text}`);
@@ -6641,14 +6911,81 @@ function hasPiiLikeValue(raw) {
   return false;
 }
 var URL_ACTION_FIELDS = ["command", "cmd", "script", "input", "target", "address", "host", "server", "baseUrl", "base_url", "apiUrl", "api_url", "remote", "repo", "repository", "source", "destination"];
+function explicitGitHubWriteRepository(command) {
+  if (command.length > 65536 || /[%!]/.test(command)) return void 0;
+  const segments = splitShellSegments(command);
+  if (segments.length !== 1) return void 0;
+  const segment = segments[0];
+  const tokens = [];
+  const token = /[ \t]*(?:'([^'\r\n]*)'|"([^"$`\\\r\n]*)"|([^\s'"$`\\|;&<>(){}\r\n]+))/gy;
+  let offset2 = 0;
+  while (offset2 < segment.length) {
+    token.lastIndex = offset2;
+    const match = token.exec(segment);
+    if (!match || token.lastIndex < segment.length && !/[ \t]/.test(segment[token.lastIndex])) return void 0;
+    if (match[3] !== void 0 && (!/^[a-z0-9_./:@=+-]+$/i.test(match[3]) || match[3].startsWith("@"))) return void 0;
+    if (match[1] !== void 0 && /[|;&<>()$`^]/.test(match[1])) return void 0;
+    tokens.push(match[1] ?? match[2] ?? match[3]);
+    offset2 = token.lastIndex;
+  }
+  if (!/^gh(?:\.exe)?$/i.test(tokens[0] || "")) return void 0;
+  let repository;
+  let resource;
+  let operation;
+  let positional;
+  const canonical = (value) => {
+    const match = /^([a-z0-9][a-z0-9.-]*\.[a-z0-9-]+)\/([a-z0-9][a-z0-9-]*)\/([a-z0-9_.-]+)$/i.exec(value);
+    if (!match || /^(?:\.|\.\.)$/.test(match[3]) || /\.git$/i.test(match[3])) return void 0;
+    return `${match[1]}/${match[2]}/${match[3]}`.toLowerCase();
+  };
+  for (let i2 = 1; i2 < tokens.length; i2++) {
+    const value = tokens[i2];
+    if (value === "-R" || value === "--repo" || value.startsWith("--repo=") || /^-R.+/.test(value)) {
+      if (repository) return void 0;
+      const selector = value === "-R" || value === "--repo" ? tokens[++i2] : value.replace(/^(?:--repo=|-R)/, "");
+      repository = canonical(selector || "");
+      if (!repository) return void 0;
+    } else if (["--body", "-b", "--body-file", "-F", "--title", "-t"].includes(value)) {
+      if (!tokens[++i2]) return void 0;
+    } else if (/^--(?:body|body-file|title)=.+/.test(value)) {
+      continue;
+    } else if (["--edit-last", "--create-if-none", "--delete-last", "--yes"].includes(value)) {
+      continue;
+    } else if (value.startsWith("-")) {
+      return void 0;
+    } else if (!resource) resource = value;
+    else if (!operation) operation = value;
+    else if (!positional) positional = value;
+    else return void 0;
+  }
+  if (!["pr", "issue"].includes(resource || "") || !["comment", "create", "edit"].includes(operation || "")) return void 0;
+  if (positional?.startsWith("https://")) {
+    const target = /^https:\/\/([^/]+)\/([^/]+)\/([^/]+)\/(pull|issues)\/[1-9][0-9]*\/?$/.exec(positional);
+    if (!target || (resource === "pr" ? target[4] !== "pull" : target[4] !== "issues")) return void 0;
+    const fromUrl = canonical(`${target[1]}/${target[2]}/${target[3]}`);
+    if (!fromUrl || repository && repository !== fromUrl) return void 0;
+    repository = fromUrl;
+  } else if (positional && !/^[1-9][0-9]*$/.test(positional)) return void 0;
+  return repository;
+}
 function extractUrl(args, _argsText) {
   const direct = args.url || args.uri || args.endpoint || args.webhookUrl || args.callbackUrl || args.href || args.link;
   if (typeof direct === "string" && direct.trim()) return direct.trim();
   for (const field of URL_ACTION_FIELDS) {
     const raw = args[field];
     if (typeof raw !== "string") continue;
-    const value = ["command", "cmd", "script", "input"].includes(field) ? shellUrlActionText(raw) : raw;
-    const found = value.match(/https?:\/\/[^\s"'<>]+/i)?.[0] || value.match(/\b(?:s3|gs|ftp|sftp|smb):\/\/[^\s"'<>]+/i)?.[0];
+    const shellField = ["command", "cmd", "script", "input"].includes(field);
+    const value = shellField ? shellUrlActionText(raw) : raw;
+    const firstUrl = (text) => text.match(/https?:\/\/[^\s"'<>]+/i)?.[0] || text.match(/\b(?:s3|gs|ftp|sftp|smb):\/\/[^\s"'<>]+/i)?.[0];
+    const outboundUrls = shellField ? splitShellSegments(value).filter((segment) => /^(?:curl(?:\.exe)?|wget(?:\.exe)?|invoke-restmethod|invoke-webrequest|irm|iwr)$/i.test(shellSegmentLead(segment)) && classifyShellSegment(segment) === "write").map(firstUrl).filter((url) => Boolean(url)) : [];
+    const externalOutbound = outboundUrls.find((url) => {
+      try {
+        return !isInternalHost(new URL(url).hostname);
+      } catch {
+        return false;
+      }
+    });
+    const found = externalOutbound || outboundUrls[0] || firstUrl(value);
     if (found) return found;
   }
   return "";
@@ -7018,6 +7355,44 @@ function classifyShellCommandOperation(command, depth = 0) {
   if (segments.length === 0) return "SHELL";
   return worstShellOp(segments.map((segment) => classifyShellSegment(segment, depth)), "read");
 }
+function provenCompoundDownload(command, detectedUrl) {
+  const segments = splitShellSegments(command).filter((segment) => /\b(?:https?|s3|gs|ftp|sftp|smb):\/\//i.test(segment));
+  if (!segments.length || !command.includes(detectedUrl)) return false;
+  return segments.every((segment) => {
+    if (/[$`{}()<>;&]/.test(segment)) return false;
+    const pipeline = splitShellSegments(segment, true);
+    if (pipeline.slice(1).some((part) => !/^(?:Select-Object|Format-Table|Format-List)\s+[\w., *-]+$|^Out-Null$/i.test(part))) return false;
+    const raw = pipeline[0];
+    const pieces = raw.match(/"[^"\r\n]*"|'[^'\r\n]*'|[^\s"']+/g) || [];
+    if (pieces.join("").replace(/\s/g, "") !== raw.replace(/\s/g, "")) return false;
+    const tokens = pieces.map((piece) => piece.replace(/^["']|["']$/g, ""));
+    if (!/^(?:curl(?:\.exe)?|wget(?:\.exe)?|Invoke-RestMethod|Invoke-WebRequest|irm|iwr)$/i.test(tokens.shift() || "")) return false;
+    let urls = 0;
+    for (let i2 = 0; i2 < tokens.length; i2++) {
+      const token = tokens[i2];
+      if (/^https?:\/\//i.test(token)) {
+        urls++;
+        continue;
+      }
+      if (/^-Uri$/i.test(token) && /^https?:\/\//i.test(tokens[i2 + 1] || "")) {
+        urls++;
+        i2++;
+        continue;
+      }
+      if (/^(?:-X|--request|-Method)$/.test(token) && /^(?:GET|HEAD|OPTIONS)$/i.test(tokens[i2 + 1] || "")) {
+        i2++;
+        continue;
+      }
+      if (/^-[sfSLI]+$|^--(?:silent|fail|location|head)$|^-UseBasicParsing$/.test(token)) continue;
+      if (/^-TimeoutSec$/i.test(token) && /^\d+$/.test(tokens[i2 + 1] || "")) {
+        i2++;
+        continue;
+      }
+      return false;
+    }
+    return urls === 1;
+  });
+}
 function isInternalHost(hostname) {
   const host = hostname.toLowerCase();
   if (!host || host === "localhost" || host === "::1" || host.endsWith(".local") || host.endsWith(".internal")) return true;
@@ -7175,6 +7550,7 @@ function inferToolContext(toolName, args) {
   let operation = toolName;
   const toolNameLower = toolName.toLowerCase();
   const argsText = stringifyArgs(args);
+  const commandText = String(args.command || args.cmd || args.code || args.script || args.input || "");
   const retryCount = Number(args.retryCount ?? args.retries ?? args.attempts ?? 0);
   const fanoutCount = Number(args.fanoutCount ?? args.recipientCount ?? args.childCalls ?? (Array.isArray(args.recipients) ? args.recipients.length : 0));
   const burstCount = Math.max(
@@ -7214,7 +7590,7 @@ function inferToolContext(toolName, args) {
     }
   }
   if (operation === toolName && CODE_EXEC_TOOL_NAME_RE.test(nameWords)) {
-    operation = classifyShellCommandOperation(String(args.command || args.code || args.script || args.input || ""));
+    operation = classifyShellCommandOperation(commandText);
   }
   const pathArg = args.path || args.filepath || args.file || args.filename || "";
   if (typeof pathArg === "string" && pathArg.length > 0) {
@@ -7231,13 +7607,14 @@ function inferToolContext(toolName, args) {
     operation = methodArg;
     if (args.url) context.url = args.url;
   }
-  const detectedUrl = extractUrl(args, argsText);
+  const provenReadUrls = isCodeExecTool && !hasSecretLikeValue(argsText) ? [...provenInlineJavaScriptReadUrls(commandText), ...provenPowerShellQueryUrls(commandText)] : [];
+  const detectedUrl = provenReadUrls[0] || extractUrl(args, argsText);
   if (detectedUrl) {
     context.url = detectedUrl;
     try {
       const parsed = new URL(detectedUrl);
       const hostType = isInternalHost(parsed.hostname) ? "internal" : "external";
-      const inbound = operation === "read" || ["GET", "HEAD", "OPTIONS", "SELECT", "SHOW", "DESCRIBE", "EXPLAIN"].includes(operation) || operation === "SHELL" && isCodeExecTool && !hasSecretLikeValue(argsText) && provenInlineJavaScriptRead(String(args.command || args.code || args.script || args.input || ""), detectedUrl) || operation === toolName && /\b(fetch|get|read|search|list|lookup|browse|navigate|download|clone|pull|view|open|crawl|scrape)\b/.test(nameWords) && !/\b(post|put|send|upload|push|write|submit|publish|export|create|update|delete|patch)\b/.test(nameWords);
+      const inbound = operation === "read" || ["GET", "HEAD", "OPTIONS", "SELECT", "SHOW", "DESCRIBE", "EXPLAIN"].includes(operation) || isCodeExecTool && !hasSecretLikeValue(argsText) && provenCompoundDownload(commandText, detectedUrl) || provenReadUrls.includes(detectedUrl) || operation === toolName && /\b(fetch|get|read|search|list|lookup|browse|navigate|download|clone|pull|view|open|crawl|scrape)\b/.test(nameWords) && !/\b(post|put|send|upload|push|write|submit|publish|export|create|update|delete|patch)\b/.test(nameWords);
       context["destination.domain"] = parsed.hostname;
       context["url.risk"] = hostType;
       if (inbound) {
@@ -7265,6 +7642,15 @@ function inferToolContext(toolName, args) {
     context.amount = String(args.amount ?? args.price ?? args.total);
   }
   context["action.kind"] = isCodeExecTool || toolNameLower === "shell" ? "shell" : context.query !== void 0 && operation !== toolName && /^(SELECT|INSERT|UPDATE|DELETE|DROP|CREATE|ALTER|TRUNCATE|GRANT|REVOKE|SHOW|DESCRIBE|EXPLAIN)$/.test(operation) ? "database" : ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"].includes(methodArg) ? "http" : context.path !== void 0 && (operation === "read" || operation === "write" || LOCAL_FILE_ACTION_RE.test(toolName) || FILE_REMOVAL_TOOL_RE.test(toolName)) ? "file" : "tool";
+  delete context["destination.repository"];
+  if (isCodeExecTool) {
+    const repository = explicitGitHubWriteRepository(String(args.command || args.cmd || args.code || args.script || args.input || ""));
+    if (repository) {
+      context["destination.repository"] = repository;
+      context["destination.domain"] = repository.split("/")[0];
+      context["destination.type"] = isInternalHost(context["destination.domain"]) ? "internal" : "external";
+    }
+  }
   return { operation, context };
 }
 function inferInventoryToolOperations(toolName, toolActions = []) {

package/dist/version.json

@@ -1,3 +1,3 @@
 {
-  "version": "1.34.11"
+  "version": "1.34.14"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fullcourtdefense-cli",
-  "version": "1.34.11",
+  "version": "1.34.14",
   "description": "Full Court Defense CLI — security scanning for AI agents from your terminal",
   "main": "dist/index.js",
   "bin": {