@blogic-cz/agent-tools 1.10.1 → 1.12.0

package/src/credential-guard/ir.ts

@@ -0,0 +1,139 @@
+export type Span = { readonly start: number; readonly end: number };
+export type Script = {
+  readonly kind: "script";
+  readonly dialect: "bash" | "powershell";
+  readonly source: string;
+  readonly body: List;
+  readonly span: Span;
+};
+export type List = { readonly items: readonly AndOr[] };
+export type AndOr = {
+  readonly first: Pipeline;
+  readonly background: boolean;
+  readonly rest: readonly { readonly op: "&&" | "||"; readonly pipeline: Pipeline }[];
+};
+export type Pipeline = {
+  readonly negated: boolean;
+  readonly stderr: boolean;
+  readonly commands: readonly Command[];
+};
+export type Command =
+  | SimpleCommand
+  | {
+      readonly kind: "group";
+      readonly subshell: boolean;
+      readonly body: List;
+      readonly redirects: readonly Redirect[];
+      readonly span: Span;
+    }
+  | {
+      readonly kind: "for";
+      readonly name: string;
+      readonly items: readonly Word[];
+      readonly body: List;
+      readonly redirects: readonly Redirect[];
+      readonly span: Span;
+    }
+  | {
+      readonly kind: "while";
+      readonly condition: List;
+      readonly body: List;
+      readonly redirects: readonly Redirect[];
+      readonly span: Span;
+    }
+  | {
+      readonly kind: "until";
+      readonly condition: List;
+      readonly body: List;
+      readonly redirects: readonly Redirect[];
+      readonly span: Span;
+    }
+  | {
+      readonly kind: "if";
+      readonly branches: readonly { readonly condition: List; readonly body: List }[];
+      readonly otherwise: List | null;
+      readonly redirects: readonly Redirect[];
+      readonly span: Span;
+    }
+  | {
+      readonly kind: "case";
+      readonly subject: Word;
+      readonly arms: readonly { readonly patterns: readonly Word[]; readonly body: List }[];
+      readonly redirects: readonly Redirect[];
+      readonly span: Span;
+    }
+  | { readonly kind: "test"; readonly words: readonly Word[]; readonly span: Span };
+export type SimpleCommand = {
+  readonly kind: "simple";
+  readonly assignments: readonly Assignment[];
+  readonly argv: readonly Word[];
+  readonly redirects: readonly Redirect[];
+  readonly span: Span;
+};
+export type Assignment = {
+  readonly operation: "replace" | "opaque";
+  readonly name: string;
+  readonly value: Word;
+  readonly exported: boolean;
+};
+export type Word = {
+  readonly split: boolean;
+  readonly parts: readonly WordPart[];
+  readonly span: Span;
+};
+export type WordPart =
+  | { readonly kind: "literal"; readonly text: string; readonly quoted: boolean }
+  | { readonly kind: "glob"; readonly text: string }
+  | { readonly kind: "brace"; readonly alternatives: readonly string[] }
+  | {
+      readonly kind: "parameter";
+      readonly name: string;
+      readonly ambient: boolean;
+      readonly operator: "plain" | "default" | "alternate" | "length";
+      readonly operand: Word | null;
+      readonly span: Span;
+    }
+  | { readonly kind: "special"; readonly name: string }
+  | { readonly kind: "command-substitution"; readonly body: Script }
+  | { readonly kind: "process-substitution"; readonly body: Script };
+export type Redirect = (
+  | {
+      readonly kind: "file";
+      readonly op: "<" | ">" | ">>" | "<>" | ">|" | "&>" | "&>>";
+      readonly target: Word;
+    }
+  | { readonly kind: "duplicate"; readonly input: boolean; readonly target: string }
+  | { readonly kind: "heredoc"; readonly body: Word; readonly literal: boolean }
+  | { readonly kind: "herestring"; readonly body: Word }
+) & { readonly fd: number | null };
+export type ParseErrorCode =
+  | "syntax"
+  | "unterminated-quote"
+  | "unterminated-heredoc"
+  | "unterminated-substitution"
+  | "function-definition"
+  | "unsupported-keyword"
+  | "indirect-expansion"
+  | "unsupported-parameter-operator"
+  | "depth-limit"
+  | "size-limit"
+  | "work-limit";
+export type ParseError = {
+  readonly kind: "parse-error";
+  readonly code: ParseErrorCode;
+  readonly span: Span;
+};
+export const MAX_ANALYSIS_UNITS = 4096;
+export const MAX_PARSE_DEPTH = 8;
+export const MAX_SCRIPT_BYTES = 262144;
+export function literalWord(text: string, span: Span = { start: 0, end: 0 }): Word {
+  return { split: false, parts: [{ kind: "literal", text, quoted: true }], span };
+}
+export function wordText(word: Word): string | undefined {
+  let text = "";
+  for (const part of word.parts) {
+    if (part.kind !== "literal") return undefined;
+    text += part.text;
+  }
+  return text;
+}

package/src/credential-guard/literal-output.ts

@@ -0,0 +1,8 @@
+export function formatLiteralPrintf(argv: readonly string[]): string | null {
+  const start = argv[0] === "--" ? 1 : 0;
+  const format = argv[start];
+  if (format !== "%s" && format !== "%s\\n" && format !== "%s ") return null;
+  const suffix = format === "%s\\n" ? "\n" : format === "%s " ? " " : "";
+  const args = argv.slice(start + 1);
+  return (args.length ? args : [""]).map((word) => word + suffix).join("");
+}

package/src/credential-guard/passive-awk.ts

@@ -0,0 +1,239 @@
+export function isPassiveAwkProgram(text: string): boolean {
+  if (text.length > 65_536) return false;
+  const tokens: string[] = [];
+  const reserved = new Set([
+    "BEGIN",
+    "END",
+    "if",
+    "else",
+    "for",
+    "while",
+    "do",
+    "in",
+    "print",
+    "printf",
+    "next",
+    "nextfile",
+    "exit",
+    "break",
+    "continue",
+    "delete",
+    "function",
+    "getline",
+    "system",
+    "close",
+    "fflush",
+  ]);
+  const variables = new Set([
+    "NR",
+    "FNR",
+    "NF",
+    "FILENAME",
+    "RSTART",
+    "RLENGTH",
+    "SUBSEP",
+    "FS",
+    "RS",
+    "OFS",
+    "ORS",
+    "OFMT",
+    "CONVFMT",
+  ]);
+  const functions = new Set([
+    "length",
+    "substr",
+    "index",
+    "int",
+    "tolower",
+    "toupper",
+    "split",
+    "match",
+    "sub",
+    "gsub",
+    "sprintf",
+    "sqrt",
+    "log",
+    "exp",
+  ]);
+  const local = (token: string): boolean =>
+    /^[a-z_][A-Za-z0-9_]*$/.test(token) && !reserved.has(token) && !functions.has(token);
+  const constant = (token: string): boolean =>
+    /^["0-9]/.test(token) || (token.startsWith("/") && token.length > 1);
+  const lexer =
+    /[ \t\r]+|\n|"(?:[^"\\\n]|\\[^\n])*"|[0-9]+(?:\.[0-9]+)?|[A-Za-z_][A-Za-z0-9_]*|&&|\|\||==|!=|<=|>=|!~|\+\+|--|[+*%/-]=|[${}[\](),;!~+*%<>?:=-]/y;
+  let offset = 0;
+  let parentheses = 0;
+  while (offset < text.length) {
+    if (text[offset] === "/") {
+      const previous = tokens.at(-1) ?? "";
+      const division =
+        constant(previous) ||
+        variables.has(previous) ||
+        functions.has(previous) ||
+        local(previous) ||
+        [")", "]", "++", "--"].includes(previous);
+      if (division) {
+        tokens.push(text[offset + 1] === "=" ? "/=" : "/");
+        offset += text[offset + 1] === "=" ? 2 : 1;
+      } else {
+        const start = offset++;
+        let closed = false;
+        while (offset < text.length) {
+          const ch = text[offset++];
+          if (ch === "\\") {
+            if (offset === text.length || text[offset] === "\n") return false;
+            offset++;
+          } else if (ch === "\n") return false;
+          else if (ch === "/") {
+            closed = true;
+            break;
+          }
+        }
+        if (!closed) return false;
+        tokens.push(text.slice(start, offset));
+      }
+    } else {
+      lexer.lastIndex = offset;
+      const match = lexer.exec(text);
+      if (!match) return false;
+      offset = lexer.lastIndex;
+      const token = match[0];
+      if (token === "(") parentheses++;
+      if (token === ")") parentheses--;
+      if (token === "\n") {
+        if (parentheses === 0) tokens.push(";");
+      } else if (!/^\s/.test(token)) tokens.push(token);
+    }
+    if (tokens.length > 4096) return false;
+  }
+  let position = 0;
+  const take = (token: string): boolean => {
+    if (tokens[position] !== token) return false;
+    position++;
+    return true;
+  };
+  const operators = new Set([
+    "&&",
+    "||",
+    "==",
+    "!=",
+    "<",
+    "<=",
+    ">",
+    ">=",
+    "~",
+    "!~",
+    "+",
+    "-",
+    "*",
+    "/",
+    "%",
+    "in",
+    "=",
+    "+=",
+    "-=",
+    "*=",
+    "/=",
+    "%=",
+  ]);
+  const startsAtom = (): boolean => {
+    const token = tokens[position] ?? "";
+    return (
+      constant(token) ||
+      ["$", "("].includes(token) ||
+      variables.has(token) ||
+      local(token) ||
+      functions.has(token)
+    );
+  };
+  const atom = (depth: number): boolean => {
+    if (depth > 64) return false;
+    if (take("!") || take("-") || take("+") || take("++") || take("--")) return atom(depth + 1);
+    if (take("$")) return atom(depth + 1);
+    if (take("(")) return expression(depth + 1) && take(")");
+    const token = tokens[position] ?? "";
+    if (constant(token)) {
+      position++;
+      return true;
+    }
+    if (variables.has(token) || local(token)) {
+      position++;
+      if (tokens[position] === "(") return false;
+      if (take("[")) {
+        if (!expression(depth + 1)) return false;
+        while (take(",")) if (!expression(depth + 1)) return false;
+        if (!take("]")) return false;
+      }
+      if (!take("++")) take("--");
+      return true;
+    }
+    if (!functions.has(token)) return false;
+    position++;
+    if (!take("(")) return token === "length";
+    if (take(")")) return token === "length";
+    if (!expression(depth + 1)) return false;
+    while (take(",")) if (!expression(depth + 1)) return false;
+    return take(")");
+  };
+  const expression = (depth: number, printing = false): boolean => {
+    if (!atom(depth)) return false;
+    while (true) {
+      const operator = tokens[position] ?? "";
+      if (operators.has(operator)) {
+        if (printing && operator === ">") return false;
+        position++;
+        if (!atom(depth)) return false;
+      } else if (take("?")) {
+        return expression(depth + 1, printing) && take(":") && expression(depth + 1, printing);
+      } else if (startsAtom()) {
+        if (!atom(depth)) return false;
+      } else return true;
+    }
+  };
+  const block = (depth: number): boolean => {
+    if (depth > 64 || !take("{")) return false;
+    while (!take("}")) {
+      if (take(";")) continue;
+      if (!statement(depth + 1)) return false;
+    }
+    return true;
+  };
+  const statement = (depth: number): boolean => {
+    if (depth > 64) return false;
+    if (tokens[position] === "{") return block(depth + 1);
+    if (take("if")) {
+      if (!take("(") || !expression(depth + 1) || !take(")") || !statement(depth + 1)) return false;
+      return !take("else") || statement(depth + 1);
+    }
+    if (take("for")) {
+      if (!take("(") || !expression(depth + 1)) return false;
+      if (take(";")) {
+        if (!expression(depth + 1) || !take(";") || !expression(depth + 1)) return false;
+      }
+      return take(")") && statement(depth + 1);
+    }
+    if (take("print") || take("printf")) {
+      if (![";", "}"].includes(tokens[position] ?? "")) {
+        if (!expression(depth + 1, true)) return false;
+        while (take(",")) if (!expression(depth + 1, true)) return false;
+      }
+    } else if (take("exit")) {
+      if (![";", "}"].includes(tokens[position] ?? "") && !expression(depth + 1)) return false;
+    } else if (!take("next") && !take("break") && !take("continue") && !expression(depth + 1))
+      return false;
+    return take(";") || tokens[position] === "}" || tokens[position] === "else";
+  };
+  let rules = 0;
+  while (position < tokens.length) {
+    if (take(";")) continue;
+    if (tokens[position] !== "{") {
+      if (!take("BEGIN") && !take("END") && !expression(0)) return false;
+      if (take(",") && !expression(0)) return false;
+    }
+    rules++;
+    if (tokens[position] === "{") {
+      if (!block(0)) return false;
+    } else if (position < tokens.length && !take(";")) return false;
+  }
+  return rules > 0;
+}

package/src/credential-guard/passive-jq.ts

@@ -1,12 +1,30 @@
 /** Closed admission grammar, not an evaluator. Unknown syntax never acquires a proof. */
 export function isPassiveJqFilter(filter: string): boolean {
+  return admitFilter(filter, 0, new Set());
+}
+
+function admitFilter(
+  filter: string,
+  interpolationDepth: number,
+  inherited: ReadonlySet<string>,
+): boolean {
+  const bindings = new Set(inherited);
+  if (interpolationDepth > 32) return false;
   if (filter.length > 65_536) return false;
   if (new TextEncoder().encode(filter).byteLength > 65_536) return false;
   const tokens: string[] = [];
   const lexer =
-    /\s+|"(?:[^"\\\x00-\x1f]|\\(?:["\\/bfnrt]|u[0-9a-fA-F]{4}))*"|(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?|[A-Za-z_][A-Za-z0-9_]*|\/\/|==|!=|<=|>=|[.{}[\]():,?|+*/%<>-]/y; // eslint-disable-line eslint/no-control-regex -- JSON strings exclude literal control bytes.
+    /\s+|"(?:[^"\\\x00-\x1f]|\\(?:["\\/bfnrt]|u[0-9a-fA-F]{4}))*"|(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?|[$@]?[A-Za-z_][A-Za-z0-9_]*|\.[A-Za-z_][A-Za-z0-9_]*|\.\.|\/\/=|[|+*/%-]=|\/\/|==|!=|<=|>=|=|[.{}[\]():,;?|+*/%<>-]/y; // eslint-disable-line eslint/no-control-regex -- JSON strings exclude literal control bytes.
   let offset = 0;
   while (offset < filter.length) {
+    if (filter[offset] === '"') {
+      const quoted = readString(filter, offset, 0);
+      if (!quoted) return false;
+      tokens.push(filter.slice(offset, quoted.end));
+      if (tokens.length > 4096) return false;
+      offset = quoted.end;
+      continue;
+    }
     lexer.lastIndex = offset;
     const match = lexer.exec(filter);
     if (!match) return false;
@@ -22,7 +40,18 @@ export function isPassiveJqFilter(filter: string): boolean {
   };
   const identifier = (token: string | undefined): boolean =>
     /^[A-Za-z_][A-Za-z0-9_]*$/.test(token ?? "");
-  const string = (token: string | undefined): boolean => token?.startsWith('"') === true;
+  const string = (token: string | undefined): boolean => {
+    if (!token?.startsWith('"')) return false;
+    const quoted = readString(token, 0, 0);
+    return (
+      quoted !== undefined &&
+      quoted.interpolations.every(([start, end]) =>
+        admitFilter(token.slice(start, end), interpolationDepth + 1, bindings),
+      )
+    );
+  };
+  const variable = (token: string | undefined): token is string =>
+    /^\$[A-Za-z_][A-Za-z0-9_]*$/.test(token ?? "") && token !== "$ENV";
   const number = (token: string | undefined): boolean => /^[0-9]/.test(token ?? "");
   const noArgs = new Set([
     "length",
@@ -30,6 +59,16 @@ export function isPassiveJqFilter(filter: string): boolean {
     "keys_unsorted",
     "type",
     "values",
+    "objects",
+    "arrays",
+    "strings",
+    "numbers",
+    "booleans",
+    "nulls",
+    "scalars",
+    "iterables",
+    "first",
+    "last",
     "empty",
     "add",
     "min",
@@ -41,6 +80,26 @@ export function isPassiveJqFilter(filter: string): boolean {
     "reverse",
     "to_entries",
     "from_entries",
+    "tostring",
+    "tonumber",
+    "tojson",
+    "fromjson",
+    "ascii_downcase",
+    "ascii_upcase",
+    "floor",
+    "ceil",
+    "round",
+    "abs",
+    "utf8bytelength",
+    "@text",
+    "@json",
+    "@html",
+    "@uri",
+    "@csv",
+    "@tsv",
+    "@sh",
+    "@base64",
+    "@base64d",
   ]);
   const oneArg = new Set([
     "map",
@@ -54,8 +113,37 @@ export function isPassiveJqFilter(filter: string): boolean {
     "any",
     "all",
     "join",
+    "split",
+    "startswith",
+    "endswith",
+    "ltrimstr",
+    "rtrimstr",
+    "test",
+    "index",
+    "rindex",
+    "indices",
+    "min_by",
+    "max_by",
+    "del",
+    "with_entries",
+    "getpath",
+  ]);
+  const multipleArgs = new Map<string, readonly number[]>([
+    ["test", [1, 2]],
+    ["match", [1, 2]],
+    ["capture", [1, 2]],
+    ["sub", [2, 3]],
+    ["gsub", [2, 3]],
   ]);
   const operators = new Set([
+    "=",
+    "|=",
+    "+=",
+    "-=",
+    "*=",
+    "/=",
+    "%=",
+    "//=",
     "|",
     "//",
     "==",
@@ -74,18 +162,32 @@ export function isPassiveJqFilter(filter: string): boolean {
   ]);
   const expression = (depth: number, commas = false): boolean => {
     if (depth > 64 || !term(depth)) return false;
-    const nextOperator = () =>
-      operators.has(tokens[position] ?? "") || (commas && tokens[position] === ",");
-    while (nextOperator()) {
-      position++;
+    while (true) {
+      if (take("as")) {
+        const name = tokens[position++];
+        if (!variable(name) || !take("|")) return false;
+        bindings.add(name);
+      } else if (operators.has(tokens[position] ?? "") || (commas && tokens[position] === ",")) {
+        position++;
+      } else break;
       if (!term(depth)) return false;
     }
     return true;
   };
+  const field = (): boolean => /^\.[A-Za-z_]/.test(tokens[position] ?? "");
   const term = (depth: number): boolean => {
     if (take("-")) return number(tokens[position]) && (position++, true);
-    if (take(".")) {
-      if (identifier(tokens[position]) || string(tokens[position])) position++;
+    if (take("if")) {
+      do {
+        if (!expression(depth + 1) || !take("then") || !expression(depth + 1)) return false;
+      } while (take("elif"));
+      if (!take("else") || !expression(depth + 1) || !take("end")) return false;
+    } else if (field()) {
+      position++;
+    } else if (take("..")) {
+      // Recursive descent only selects values from the current input.
+    } else if (take(".")) {
+      if (string(tokens[position])) position++;
     } else if (take("(")) {
       if (!expression(depth + 1, true) || !take(")")) return false;
     } else if (take("[")) {
@@ -93,37 +195,56 @@ export function isPassiveJqFilter(filter: string): boolean {
     } else if (take("{")) {
       if (!take("}")) {
         do {
-          const key = tokens[position];
-          if (!identifier(key) && !string(key)) return false;
-          position++;
-          if (take(":")) {
-            if (!expression(depth + 1)) return false;
-          } else if (!identifier(key)) return false;
+          if (take("(")) {
+            if (!expression(depth + 1) || !take(")") || !take(":") || !expression(depth + 1))
+              return false;
+          } else {
+            const key = tokens[position];
+            if (!identifier(key) && !string(key)) return false;
+            position++;
+            if (take(":")) {
+              if (!expression(depth + 1)) return false;
+            } else if (!identifier(key)) return false;
+          }
         } while (take(","));
         if (!take("}")) return false;
       }
     } else {
       const token = tokens[position];
-      if (string(token) || number(token) || ["true", "false", "null"].includes(token ?? ""))
+      if (
+        (variable(token) && bindings.has(token)) ||
+        string(token) ||
+        number(token) ||
+        ["true", "false", "null"].includes(token ?? "")
+      )
         position++;
-      else if (noArgs.has(token ?? "")) position++;
-      else if (oneArg.has(token ?? "")) {
+      else if (noArgs.has(token ?? "")) {
         position++;
-        if (!take("(") || !expression(depth + 1) || !take(")")) return false;
+        if (token?.startsWith("@") && string(tokens[position])) position++;
+      } else if (oneArg.has(token ?? "") || multipleArgs.has(token ?? "")) {
+        position++;
+        if (!take("(") || !expression(depth + 1)) return false;
+        let count = 1;
+        while (take(";")) {
+          count++;
+          if (!expression(depth + 1)) return false;
+        }
+        if (!(multipleArgs.get(token ?? "") ?? [1]).includes(count) || !take(")")) return false;
       } else return false;
     }
     while (true) {
       if (take("?")) continue;
+      if (field()) {
+        position++;
+        continue;
+      }
       if (take(".")) {
-        if (!identifier(tokens[position]) && !string(tokens[position])) return false;
+        if (!string(tokens[position])) return false;
         position++;
       } else if (take("[")) {
         if (!take("]")) {
-          if (take("-")) {
-            if (!number(tokens[position])) return false;
-            position++;
-          } else if (string(tokens[position]) || number(tokens[position])) position++;
-          else return false;
+          if (tokens[position] !== ":" && !expression(depth + 1, true)) return false;
+          if (take(":") && tokens[position] !== "]" && !expression(depth + 1)) return false;
           if (!take("]")) return false;
         }
       } else break;
@@ -133,6 +254,44 @@ export function isPassiveJqFilter(filter: string): boolean {
   return expression(0, true) && position === tokens.length;
 }
 
+function readString(
+  text: string,
+  start: number,
+  depth: number,
+): { end: number; interpolations: [number, number][] } | undefined {
+  if (depth > 32) return undefined;
+  const interpolations: [number, number][] = [];
+  let offset = start + 1;
+  while (offset < text.length) {
+    const character = text[offset++];
+    if (character === '"') return { end: offset, interpolations };
+    if (!character || character.charCodeAt(0) < 32) return undefined;
+    if (character !== "\\") continue;
+    const escape = text[offset++];
+    if (escape === "(") {
+      const expressionStart = offset;
+      let parentheses = 1;
+      while (offset < text.length && parentheses > 0) {
+        if (text[offset] === '"') {
+          const nested = readString(text, offset, depth + 1);
+          if (!nested) return undefined;
+          offset = nested.end;
+        } else {
+          const token = text[offset++];
+          if (token === "(") parentheses++;
+          if (token === ")") parentheses--;
+        }
+      }
+      if (parentheses !== 0) return undefined;
+      interpolations.push([expressionStart, offset - 1]);
+    } else if (escape === "u") {
+      if (!/^[0-9a-fA-F]{4}$/.test(text.slice(offset, offset + 4))) return undefined;
+      offset += 4;
+    } else if (!escape || !'"\\/bfnrt'.includes(escape)) return undefined;
+  }
+  return undefined;
+}
+
 /** Only known formatting/input flags and one literal program, followed by file operands. */
 export function passiveJqProgramIndex(argv: string[]): number | undefined {
   if (argv[0]?.split("/").at(-1) !== "jq") return undefined;