@lazyingart/agintiflow 0.20.88 → 0.20.90

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.88",
+  "version": "0.20.90",
   "type": "module",
   "description": "Low-cost, project-aware Web and CLI agents with DeepSeek/Venice/OpenAI routing, visible tool calls, durable sessions, scouts, AAPS, SCS, and guarded local execution.",
   "license": "Apache-2.0",

package/scripts/smoke-coding-tools.js

@@ -276,6 +276,30 @@ try {
   );
   assert(readonlyProbePolicy.allowed, "read-only toolchain probe sequence should not require package-install-policy=allow");
   assert(readonlyProbePolicy.category === "read-only", "read-only toolchain probe sequence should be classified as read-only");
+  const readonlyVersionPipelinePolicy = evaluateCommandPolicy(
+    "which pdflatex latexmk python3 2>&1; pdflatex --version 2>&1 | head -2; latexmk --version 2>&1 | head -2",
+    dockerWorkspaceNoInstallsPolicy
+  );
+  assert(readonlyVersionPipelinePolicy.allowed, "read-only version probe pipelines should not require package-install-policy=allow");
+  assert(readonlyVersionPipelinePolicy.category === "read-only", "read-only version probe pipelines should be classified as read-only");
+  const readonlyTestEchoPolicy = evaluateCommandPolicy(
+    'test -f /usr/bin/pdflatex && echo "pdflatex: FOUND" || echo "pdflatex: NOT FOUND"; test -f /usr/bin/latexmk && echo "latexmk: FOUND" || echo "latexmk: NOT FOUND"; python3 --version 2>&1',
+    dockerWorkspaceNoInstallsPolicy
+  );
+  assert(readonlyTestEchoPolicy.allowed, "read-only test/echo probe sequence should not require package-install-policy=allow");
+  assert(readonlyTestEchoPolicy.category === "read-only", "read-only test/echo probe sequence should be classified as read-only");
+  const pdflatexCompilePolicy = evaluateCommandPolicy(
+    'cd profile-latex-20260506 && pdflatex -interaction=nonstopmode -halt-on-error main.tex 2>&1; echo "PDFLATEX_EXIT:$?"',
+    dockerWorkspaceNoInstallsPolicy
+  );
+  assert(pdflatexCompilePolicy.allowed, "workspace-local pdflatex compile should be allowed without package installs");
+  assert(pdflatexCompilePolicy.category === "toolchain", "workspace-local pdflatex compile should be classified as toolchain");
+  const latexmkCompilePolicy = evaluateCommandPolicy(
+    'cd profile-latex-20260506 && latexmk -pdf main.tex 2>&1; echo "LATEXMK_EXIT:$?"',
+    dockerWorkspaceNoInstallsPolicy
+  );
+  assert(latexmkCompilePolicy.allowed, "workspace-local latexmk compile should be allowed without package installs");
+  assert(latexmkCompilePolicy.category === "toolchain", "workspace-local latexmk compile should be classified as toolchain");
   const curlPolicy = evaluateCommandPolicy("curl -s -o /dev/null -w '%{http_code}' https://github.com/lazyingart/AgInTiFlow.git", dockerWorkspacePolicy);
   assert(curlPolicy.allowed, "curl URL probe with flags should be allowed in docker-workspace allow mode");
   assert(curlPolicy.needsNetwork, "curl URL probe with flags was not classified as network");
@@ -736,6 +760,10 @@ try {
           "auto_system_pro_route",
           "auto_engineering_guidance",
           "command_policy_readonly_probe_sequence_no_installs",
+          "command_policy_readonly_version_pipeline_no_installs",
+          "command_policy_readonly_test_echo_no_installs",
+          "command_policy_pdflatex_compile_no_installs",
+          "command_policy_latexmk_compile_no_installs",
           "command_policy_git_clone_network",
           "command_policy_safe_chmod_sequence",
           "command_policy_cd_workspace",

package/src/command-policy.js

@@ -23,6 +23,10 @@ const READ_ONLY_PATTERNS = [
   /^python(?:3)?\s+--version$/,
   /^pip(?:3)?\s+--version$/,
   /^conda\s+--version$/,
+  /^(?:pdflatex|latexmk)\s+--version$/,
+  /^test\s+-[efdx]\s+[-\w./~]+$/,
+  /^true$/,
+  /^false$/,
   /^echo(?:\s+.+)?$/,
 ];
 
@@ -261,7 +265,7 @@ function classifyGitClone(normalized) {
 }
 
 function classifySimpleCommand(normalized) {
-  const readOnlyCommand = stripBenignRedirections(normalized);
+  const benignRedirectCommand = stripBenignRedirections(normalized);
   if (ALWAYS_BLOCKED_PATTERNS.some((pattern) => pattern.test(normalized))) {
     return { category: "blocked", reason: "Command is blocked because it may expose secrets or publish packages." };
   }
@@ -314,7 +318,7 @@ function classifySimpleCommand(normalized) {
   const gitCloneClassification = classifyGitClone(normalized);
   if (gitCloneClassification) return gitCloneClassification;
 
-  const unquoted = stripQuotedSegments(readOnlyCommand);
+  const unquoted = stripQuotedSegments(benignRedirectCommand);
   const lowered = ` ${unquoted.toLowerCase()} `;
   if (BLOCKED_WRITE_TOKENS.some((part) => lowered.includes(part))) {
     return {
@@ -333,25 +337,25 @@ function classifySimpleCommand(normalized) {
     };
   }
 
-  if (matchAny(READ_ONLY_PATTERNS, readOnlyCommand) || isReadOnlyFindCommand(normalized)) {
+  if (matchAny(READ_ONLY_PATTERNS, benignRedirectCommand) || isReadOnlyFindCommand(normalized)) {
     return { category: "read-only", needsNetwork: false, writesWorkspace: false };
   }
-  if (matchAny(TEST_PATTERNS, normalized)) {
+  if (matchAny(TEST_PATTERNS, benignRedirectCommand)) {
     return { category: "test", needsNetwork: false, writesWorkspace: false };
   }
-  if (matchAny(TOOLCHAIN_PATTERNS, normalized)) {
+  if (matchAny(TOOLCHAIN_PATTERNS, benignRedirectCommand)) {
     return { category: "toolchain", needsNetwork: false, writesWorkspace: true };
   }
-  if (matchAny(NETWORK_FETCH_PATTERNS, normalized)) {
-    return { category: "network-fetch", needsNetwork: true, writesWorkspace: /(\s-o\s|\s-O\s)/.test(normalized) };
+  if (matchAny(NETWORK_FETCH_PATTERNS, benignRedirectCommand)) {
+    return { category: "network-fetch", needsNetwork: true, writesWorkspace: /(\s-o\s|\s-O\s)/.test(benignRedirectCommand) };
   }
-  if (matchAny(SYSTEM_PACKAGE_INSTALL_PATTERNS, normalized)) {
+  if (matchAny(SYSTEM_PACKAGE_INSTALL_PATTERNS, benignRedirectCommand)) {
     return { category: "system-package-install", needsNetwork: true, writesWorkspace: false, requiresDockerRoot: true };
   }
-  if (matchAny(PACKAGE_INSTALL_PATTERNS, normalized)) {
+  if (matchAny(PACKAGE_INSTALL_PATTERNS, benignRedirectCommand)) {
     return { category: "package-install", needsNetwork: true, writesWorkspace: true };
   }
-  if (matchAny(ENV_SETUP_PATTERNS, normalized)) {
+  if (matchAny(ENV_SETUP_PATTERNS, benignRedirectCommand)) {
     return { category: "env-setup", needsNetwork: false, writesWorkspace: true };
   }
 
@@ -392,13 +396,13 @@ function splitTopLevelShellSequence(command = "") {
       quote = char;
       continue;
     }
-    if (char === ";" || (char === "&" && text[index + 1] === "&")) {
+    if (char === ";" || (char === "&" && text[index + 1] === "&") || (char === "|" && text[index + 1] === "|")) {
       const part = current.trim();
       if (!part) return null;
       parts.push(part);
       current = "";
       hadSeparator = true;
-      if (char === "&") index += 1;
+      if (char === "&" || char === "|") index += 1;
       continue;
     }
     current += char;
@@ -412,7 +416,7 @@ function splitTopLevelShellSequence(command = "") {
 function classifyShellSequence(normalized) {
   const parts = splitTopLevelShellSequence(normalized);
   if (!parts) return null;
-  const classifications = parts.map((part) => classifyCdCommand(part) || classifySimpleCommand(part));
+  const classifications = parts.map((part) => classifyCdCommand(part) || classifyPipelineSequence(part) || classifySimpleCommand(part));
   const blocked = classifications.find((classification) => classification.category === "blocked" || classification.category === "destructive");
   if (blocked) return blocked;
   const broad = classifications.find((classification) => classification.category === "general-shell");
@@ -446,6 +450,73 @@ function classifyShellSequence(normalized) {
   };
 }
 
+function splitTopLevelPipeline(command = "") {
+  const parts = [];
+  let current = "";
+  let quote = "";
+  let escaped = false;
+  let hadPipe = false;
+  const text = String(command || "");
+  for (let index = 0; index < text.length; index += 1) {
+    const char = text[index];
+    if (escaped) {
+      current += char;
+      escaped = false;
+      continue;
+    }
+    if (char === "\\") {
+      current += char;
+      escaped = true;
+      continue;
+    }
+    if (quote) {
+      current += char;
+      if (char === quote) quote = "";
+      continue;
+    }
+    if (char === "'" || char === '"') {
+      current += char;
+      quote = char;
+      continue;
+    }
+    if (char === "|" && text[index + 1] !== "|") {
+      const part = current.trim();
+      if (!part) return null;
+      parts.push(part);
+      current = "";
+      hadPipe = true;
+      continue;
+    }
+    current += char;
+  }
+  const finalPart = current.trim();
+  if (finalPart) parts.push(finalPart);
+  if (!hadPipe || parts.length < 2) return null;
+  return parts;
+}
+
+function classifyPipelineSequence(normalized) {
+  const parts = splitTopLevelPipeline(normalized);
+  if (!parts) return null;
+  const classifications = parts.map((part) => classifyCdCommand(part) || classifySimpleCommand(part));
+  const blocked = classifications.find((classification) => classification.category === "blocked" || classification.category === "destructive");
+  if (blocked) return blocked;
+  if (classifications.every((classification) => classification.category === "read-only")) {
+    return {
+      category: "read-only",
+      needsNetwork: false,
+      writesWorkspace: false,
+      reason: `Read-only shell pipeline: ${normalized}`,
+    };
+  }
+  return {
+    category: "general-shell",
+    needsNetwork: classifications.some((classification) => classification.needsNetwork),
+    writesWorkspace: classifications.some((classification) => classification.writesWorkspace),
+    reason: `Shell pipeline includes a broad segment and requires trusted shell policy: ${normalized}`,
+  };
+}
+
 function classifyCdCommand(normalized) {
   const match = normalized.match(/^cd\s+([-\w./]+)\s+&&\s+(.+)$/);
   if (!match) return null;
@@ -454,7 +525,7 @@ function classifyCdCommand(normalized) {
   if (!isSafeRelativeDir(dir) && !virtualWorkspacePath) {
     return { category: "blocked", reason: `cd target must be a safe workspace-relative directory: ${dir}` };
   }
-  const innerClassification = classifySimpleCommand(inner.trim());
+  const innerClassification = classifyShellSequence(inner.trim()) || classifyPipelineSequence(inner.trim()) || classifySimpleCommand(inner.trim());
   if (innerClassification.category === "blocked") return innerClassification;
   return { ...innerClassification, cdDir: dir, virtualWorkspacePath };
 }
@@ -463,7 +534,7 @@ export function classifyCommand(command) {
   const normalized = String(command || "").trim();
   if (!normalized) return { category: "blocked", reason: "Command is empty." };
 
-  return classifyCdCommand(normalized) || classifyShellSequence(normalized) || classifySimpleCommand(normalized);
+  return classifyCdCommand(normalized) || classifyShellSequence(normalized) || classifyPipelineSequence(normalized) || classifySimpleCommand(normalized);
 }
 
 export function evaluateCommandPolicy(command, config) {