@westbayberry/dg 2.3.0 → 2.3.2

package/dist/launcher/agent-check.js

@@ -68,8 +68,18 @@ const PIP_VALUE_FLAGS = new Set([
     "--extra-index-url", "-f", "--find-links", "-t", "--target", "--platform",
     "--python-version", "--implementation", "--abi", "--prefix", "--root", "--no-binary",
     "--only-binary", "--progress-bar",
+    // Global value-flags that can precede the `install` subcommand; without them
+    // the flag's value is mistaken for the verb and the real package is missed.
+    "--log", "--cache-dir", "--proxy", "--timeout", "--retries", "--cert", "--client-cert",
+    "--trusted-host", "--log-file", "--python",
+]);
+const NPM_VALUE_FLAGS = new Set([
+    "--registry", "--prefix", "-C", "--workspace", "-w", "--tag", "--otp",
+    // Global value-flags that can precede the subcommand.
+    "--loglevel", "--cache", "--userconfig", "--globalconfig", "--node-options", "--script-shell",
+    "--before", "--omit", "--include", "--https-proxy", "--proxy", "--cafile", "--cert", "--key",
+    "--user-agent", "--fetch-timeout", "--fetch-retries", "--maxsockets", "--network-timeout",
 ]);
-const NPM_VALUE_FLAGS = new Set(["--registry", "--prefix", "-C", "--workspace", "-w", "--tag", "--otp"]);
 function analyzeEcosystem(eco) {
     if (eco === "javascript")
         return "npm";
@@ -78,14 +88,123 @@ function analyzeEcosystem(eco) {
     return null;
 }
 function splitSegments(line) {
-    // Split on shell control operators, but not on a `&` that is part of a
-    // redirection (`2>&1`, `>&2`, `&>file`) where the `&` is glued to a `>` —
-    // shearing there turns a redirection into a phantom package token.
-    return line.split(/&&|\|\||;|\||[\n\r]|(?<!>)&(?!>)/).map((s) => s.trim()).filter(Boolean);
+    // Split on shell control operators (`&&`, `||`, `;`, `|`, newline, and a
+    // backgrounding `&`), but only OUTSIDE single/double quotes and backslash
+    // escapes — the shell treats a quoted `;`/`&&`/`|` as literal data, so a
+    // separator inside a curl header, a search query, or a JSON body must not
+    // shear the argument into a phantom command segment (a quoted `npm install`
+    // would otherwise be screened as a real install). A `$(…)`/backtick command
+    // substitution inside quotes is still reached: collectSegments extracts its
+    // body separately. A bare `&` glued to a `>` (`2>&1`, `&>file`) is part of a
+    // redirection, not a separator.
+    const segments = [];
+    let buf = "";
+    let quote = null;
+    let ansiC = false;
+    const push = () => {
+        const t = buf.trim();
+        if (t) {
+            segments.push(t);
+        }
+        buf = "";
+    };
+    for (let i = 0; i < line.length; i += 1) {
+        const ch = line[i] ?? "";
+        if (ansiC) {
+            // ANSI-C `$'…'`: a backslash escapes the next char, so `\'` does NOT close
+            // the span — track it the way lexSegment/decodeAnsiC and bash do, or the
+            // quote state desyncs and a real `;`/`&&` after it is mis-split.
+            if (ch === "\\" && i + 1 < line.length) {
+                buf += ch + line[i + 1];
+                i += 1;
+                continue;
+            }
+            buf += ch;
+            if (ch === "'") {
+                ansiC = false;
+            }
+            continue;
+        }
+        if (quote === "'") {
+            buf += ch;
+            if (ch === "'") {
+                quote = null;
+            }
+            continue;
+        }
+        if (quote === '"') {
+            if (ch === "\\" && i + 1 < line.length) {
+                buf += ch + line[i + 1];
+                i += 1;
+                continue;
+            }
+            buf += ch;
+            if (ch === '"') {
+                quote = null;
+            }
+            continue;
+        }
+        if (ch === "$" && line[i + 1] === "'") {
+            ansiC = true;
+            buf += "$'";
+            i += 1;
+            continue;
+        }
+        if (ch === "\\" && i + 1 < line.length) {
+            buf += ch + line[i + 1];
+            i += 1;
+            continue;
+        }
+        if (ch === "'" || ch === '"') {
+            quote = ch;
+            buf += ch;
+            continue;
+        }
+        if (ch === "#" && (i === 0 || /\s/.test(line[i - 1] ?? ""))) {
+            // A bash comment begins at an unquoted `#` on a word boundary and runs to
+            // end of line; the shell never executes that text, so splitting it into a
+            // phantom install segment would be a false block.
+            push();
+            while (i < line.length && line[i] !== "\n" && line[i] !== "\r") {
+                i += 1;
+            }
+            i -= 1;
+            continue;
+        }
+        if (ch === "\n" || ch === "\r" || ch === ";") {
+            push();
+            continue;
+        }
+        if (ch === "|") {
+            push();
+            if (line[i + 1] === "|") {
+                i += 1;
+            }
+            continue;
+        }
+        if (ch === "&") {
+            if (line[i + 1] === "&") {
+                push();
+                i += 1;
+                continue;
+            }
+            if (line[i - 1] === ">" || line[i + 1] === ">") {
+                buf += ch;
+                continue;
+            }
+            push();
+            continue;
+        }
+        buf += ch;
+    }
+    push();
+    return segments;
 }
 function substitutionBodies(line) {
     const bodies = [];
-    const patterns = [/\$\(([^)]*)\)/g, /`([^`]*)`/g];
+    // `$(…)`, backtick, and process substitution `<(…)` / `>(…)` all run their
+    // body as a command, so an install hidden inside one must be re-screened.
+    const patterns = [/\$\(([^)]*)\)/g, /`([^`]*)`/g, /<\(([^)]*)\)/g, />\(([^)]*)\)/g];
     for (const pattern of patterns) {
         let m;
         while ((m = pattern.exec(line)) !== null) {
@@ -332,6 +451,13 @@ const WRAPPERS = new Map([
     ["xargs", { valueFlags: new Set(["-a", "--arg-file", "-d", "--delimiter", "-E", "-e", "--eof", "-I", "-i", "--replace", "-L", "-l", "--max-lines", "-n", "--max-args", "-P", "--max-procs", "-s", "--max-chars"]) }],
 ]);
 const SHELL_EXEC = new Set(["sh", "bash", "zsh", "dash", "ash"]);
+// Control-flow keywords that introduce a command (`if …; then <cmd>`, `for …;
+// do <cmd>`, `! <cmd>`). The segmenter splits on `;`, so the command after one
+// lands at the head of its segment behind the keyword — strip it or a real
+// `do npm install <pkg>` is read as the no-op command `do`.
+const SHELL_KEYWORDS = new Set(["then", "do", "else", "elif", "!"]);
+// A `case … in <pat>) <cmd> ;;` arm label, e.g. `a)`, `*)`, `*.js)`, `a|b)`.
+const CASE_LABEL = /^[A-Za-z0-9_*?.\][|@!+-]+\)$/;
 // Package managers dg doesn't statically screen (no shim, no classifier). A
 // recognized install verb for one of these can't be screened by the hook, so it
 // defers to the runtime gate rather than waving it through silently.
@@ -374,6 +500,22 @@ function commandTokens(segment) {
         while (tokens.length > 0 && ENV_ASSIGNMENT.test(tokens[0] ?? "")) {
             tokens = tokens.slice(1);
         }
+        const kw = tokens[0] ?? "";
+        if (SHELL_KEYWORDS.has(kw)) {
+            tokens = tokens.slice(1);
+            continue;
+        }
+        if (kw === "case") {
+            const close = tokens.findIndex((t) => t.endsWith(")"));
+            if (close > 0) {
+                tokens = tokens.slice(close + 1);
+                continue;
+            }
+        }
+        if (CASE_LABEL.test(kw)) {
+            tokens = tokens.slice(1);
+            continue;
+        }
         const head = commandBasename(tokens[0] ?? "");
         if (head === "eval" && tokens.length > 1) {
             return { tokens, ok: lexed.ok, shellScript: tokens.slice(1).join(" "), ...x() };

package/dist/launcher/classify.js

@@ -7,8 +7,43 @@ const yarnProtected = new Set(["add", "install", "upgrade", "dlx", "create"]);
 const pipProtected = new Set(["install", "download", "wheel"]);
 const pipxProtected = new Set(["install", "upgrade", "inject", "run"]);
 const uvProtected = new Set(["add", "sync"]);
-const cargoProtected = new Set(["add", "install", "fetch", "update", "build", "test", "check", "run"]);
+// Only the dependency-set-changing verbs. `build`/`test`/`run`/`check` compile
+// local code (the npm `run`/`build` analog, which is passthrough) and crates are
+// not analyzable yet, so gating them just interrupts every Rust build with no
+// screening value.
+const cargoProtected = new Set(["add", "install", "fetch", "update"]);
 const passthrough = new Set(["help", "--help", "-h", "version", "--version", "-v", "list", "ls", "show", "freeze"]);
+// Recognized read-only / local / script subcommands across the managers. Used
+// only to locate the real subcommand when a global value-flag puts a non-verb
+// token first (`npm --prefix /tmp install x` → action `/tmp`, missing the
+// install). A flag value (a path, URL, or log level) is never a recognized
+// verb, so the scan steps over it; a script-runner verb (`run`, `view`) is
+// matched before any later install-looking token, so `npm run install` is not
+// mis-screened. Must contain no install verb (those live in the protected sets).
+const READ_ONLY_VERBS = new Set([
+    "run", "run-script", "start", "stop", "restart", "test", "build", "watch", "serve", "lint", "format",
+    "ls", "list", "ll", "la", "view", "show", "info", "outdated", "why", "fund", "audit", "doctor", "ping",
+    "config", "get", "cache", "whoami", "org", "team", "access", "token", "profile", "search", "dist-tag",
+    "docs", "repo", "home", "bin", "root", "prefix", "completion", "help", "version", "explain", "star", "unstar",
+    "deprecate", "sbom", "query", "explore", "pack", "publish", "link", "unlink", "prune", "rebuild",
+    "logout", "login", "adduser", "owner", "set", "init", "licenses",
+    "freeze", "check", "uninstall", "debug", "hash", "inspect", "index", "tree", "lock", "venv", "export", "python", "self",
+]);
+function findAction(args, protectedCommands) {
+    let firstPositional;
+    for (const arg of args) {
+        if (arg.startsWith("-")) {
+            continue;
+        }
+        if (firstPositional === undefined) {
+            firstPositional = arg;
+        }
+        if (protectedCommands.has(arg) || READ_ONLY_VERBS.has(arg)) {
+            return arg;
+        }
+    }
+    return firstPositional ?? "";
+}
 // pip3, pip3.12, python3, python3.11 are the canonical install commands on
 // macOS/Homebrew and many Linux distros (see BINARY_FALLBACKS in
 // resolve-real-binary.ts). The classifier keys on the base name, so a
@@ -61,8 +96,8 @@ export function classifyPackageManagerInvocation(rawManager, args) {
     return classifyByCommand(manager, args, "cargo", cargoProtected, "Cargo command can fetch crates", "rust");
 }
 function classifyByCommand(manager, args, realBinaryName, protectedCommands, protectedReason, ecosystem) {
-    const action = firstCommand(args);
-    if (protectedCommands.has(action) || containsFetchSpec(args) || initFetchesPackage(action, args, protectedCommands)) {
+    const action = findAction(args, protectedCommands);
+    if (protectedCommands.has(action) || initFetchesPackage(action, args, protectedCommands)) {
         return {
             manager,
             ecosystem,
@@ -96,7 +131,7 @@ function classifyUv(args) {
         // fetch-and-execute path that the bare `run` verb otherwise waves through.
         return protectedClassification("uv", args, "uv", "uv run --with fetches and runs a package");
     }
-    if (uvProtected.has(action) || containsFetchSpec(args)) {
+    if (uvProtected.has(action)) {
         return protectedClassification("uv", args, "uv", "uv install/fetch command");
     }
     return {
@@ -148,6 +183,3 @@ function initFetchesPackage(action, args, protectedCommands) {
 export function uvRunFetchesPackage(args) {
     return args.some((a) => a === "--with" || a === "--with-editable" || a === "--with-requirements" || a.startsWith("--with="));
 }
-function containsFetchSpec(args) {
-    return args.some((arg) => /^https?:\/\//.test(arg) || /^git\+https?:\/\//.test(arg) || /\.t(ar\.)?gz(?:$|[#?])/.test(arg));
-}

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@westbayberry/dg",
-  "version": "2.3.0",
+  "version": "2.3.2",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@westbayberry/dg",
-      "version": "2.3.0",
+      "version": "2.3.2",
       "license": "Apache-2.0",
       "dependencies": {
         "chalk": "4.1.2",

package/package.json

@@ -1,7 +1,23 @@
 {
   "name": "@westbayberry/dg",
-  "version": "2.3.0",
+  "version": "2.3.2",
   "description": "Dependency Guardian supply-chain firewall CLI",
+  "keywords": [
+    "supply-chain-security",
+    "supply-chain",
+    "npm-security",
+    "pypi-security",
+    "malware-scanner",
+    "malware-detection",
+    "dependency-scanner",
+    "npm-audit-alternative",
+    "install-time-security",
+    "typosquatting",
+    "postinstall",
+    "ai-agent-security",
+    "claude-code",
+    "security"
+  ],
   "repository": {
     "type": "git",
     "url": "git+https://github.com/WestBayBerry/DG_CLI.git"
@@ -9,7 +25,7 @@
   "bugs": {
     "url": "https://github.com/WestBayBerry/DG_CLI/issues"
   },
-  "homepage": "https://github.com/WestBayBerry/DG_CLI#readme",
+  "homepage": "https://westbayberry.com",
   "type": "module",
   "bin": {
     "dg": "./dist/bin/dg.js"