@office-ai/aioncli-core 0.2.3 → 0.18.4

package/dist/src/utils/shell-utils.js

@@ -3,8 +3,311 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import os from 'os';
+import os from 'node:os';
 import { quote } from 'shell-quote';
+import { doesToolInvocationMatch } from './tool-utils.js';
+import { spawn, spawnSync, } from 'node:child_process';
+import { Language, Parser } from 'web-tree-sitter';
+import { loadWasmBinary } from './fileUtils.js';
+export const SHELL_TOOL_NAMES = ['run_shell_command', 'ShellTool'];
+let bashLanguage = null;
+let treeSitterInitialization = null;
+let treeSitterInitializationError = null;
+class ShellParserInitializationError extends Error {
+    constructor(cause) {
+        super(`Failed to initialize bash parser: ${cause.message}`, { cause });
+        this.name = 'ShellParserInitializationError';
+    }
+}
+function toError(value) {
+    if (value instanceof Error) {
+        return value;
+    }
+    if (typeof value === 'string') {
+        return new Error(value);
+    }
+    return new Error('Unknown tree-sitter initialization error', {
+        cause: value,
+    });
+}
+async function loadBashLanguage() {
+    try {
+        treeSitterInitializationError = null;
+        const [treeSitterBinary, bashBinary] = await Promise.all([
+            loadWasmBinary(() => 
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore resolved by esbuild-plugin-wasm during bundling
+            import('web-tree-sitter/tree-sitter.wasm?binary'), 'web-tree-sitter/tree-sitter.wasm'),
+            loadWasmBinary(() => 
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore resolved by esbuild-plugin-wasm during bundling
+            import('tree-sitter-bash/tree-sitter-bash.wasm?binary'), 'tree-sitter-bash/tree-sitter-bash.wasm'),
+        ]);
+        await Parser.init({ wasmBinary: treeSitterBinary });
+        bashLanguage = await Language.load(bashBinary);
+    }
+    catch (error) {
+        bashLanguage = null;
+        const normalized = toError(error);
+        const initializationError = normalized instanceof ShellParserInitializationError
+            ? normalized
+            : new ShellParserInitializationError(normalized);
+        treeSitterInitializationError = initializationError;
+        throw initializationError;
+    }
+}
+export async function initializeShellParsers() {
+    if (!treeSitterInitialization) {
+        treeSitterInitialization = loadBashLanguage().catch((error) => {
+            treeSitterInitialization = null;
+            throw error;
+        });
+    }
+    await treeSitterInitialization;
+}
+const POWERSHELL_COMMAND_ENV = '__GCLI_POWERSHELL_COMMAND__';
+// Encode the parser script as UTF-16LE base64 so we can pass it via PowerShell's -EncodedCommand flag;
+// this avoids brittle quoting/escaping when spawning PowerShell and ensures the script is received byte-for-byte.
+const POWERSHELL_PARSER_SCRIPT = Buffer.from(`
+$ErrorActionPreference = 'Stop'
+$commandText = $env:${POWERSHELL_COMMAND_ENV}
+if ([string]::IsNullOrEmpty($commandText)) {
+  Write-Output '{"success":false}'
+  exit 0
+}
+$tokens = $null
+$errors = $null
+$ast = [System.Management.Automation.Language.Parser]::ParseInput($commandText, [ref]$tokens, [ref]$errors)
+if ($errors -and $errors.Count -gt 0) {
+  Write-Output '{"success":false}'
+  exit 0
+}
+$commandAsts = $ast.FindAll({ param($node) $node -is [System.Management.Automation.Language.CommandAst] }, $true)
+$commandObjects = @()
+foreach ($commandAst in $commandAsts) {
+  $name = $commandAst.GetCommandName()
+  if ([string]::IsNullOrWhiteSpace($name)) {
+    continue
+  }
+  $commandObjects += [PSCustomObject]@{
+    name = $name
+    text = $commandAst.Extent.Text.Trim()
+  }
+}
+[PSCustomObject]@{
+  success = $true
+  commands = $commandObjects
+} | ConvertTo-Json -Compress
+`, 'utf16le').toString('base64');
+function createParser() {
+    if (!bashLanguage) {
+        if (treeSitterInitializationError) {
+            throw treeSitterInitializationError;
+        }
+        return null;
+    }
+    try {
+        const parser = new Parser();
+        parser.setLanguage(bashLanguage);
+        return parser;
+    }
+    catch {
+        return null;
+    }
+}
+function parseCommandTree(command) {
+    const parser = createParser();
+    if (!parser || !command.trim()) {
+        return null;
+    }
+    try {
+        return parser.parse(command);
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeCommandName(raw) {
+    if (raw.length >= 2) {
+        const first = raw[0];
+        const last = raw[raw.length - 1];
+        if ((first === '"' && last === '"') || (first === "'" && last === "'")) {
+            return raw.slice(1, -1);
+        }
+    }
+    const trimmed = raw.trim();
+    if (!trimmed) {
+        return trimmed;
+    }
+    return trimmed.split(/[\\/]/).pop() ?? trimmed;
+}
+function extractNameFromNode(node) {
+    switch (node.type) {
+        case 'command': {
+            const nameNode = node.childForFieldName('name');
+            if (!nameNode) {
+                return null;
+            }
+            return normalizeCommandName(nameNode.text);
+        }
+        case 'declaration_command':
+        case 'unset_command':
+        case 'test_command': {
+            const firstChild = node.child(0);
+            if (!firstChild) {
+                return null;
+            }
+            return normalizeCommandName(firstChild.text);
+        }
+        default:
+            return null;
+    }
+}
+function collectCommandDetails(root, source) {
+    const stack = [root];
+    const details = [];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (!current) {
+            continue;
+        }
+        const commandName = extractNameFromNode(current);
+        if (commandName) {
+            details.push({
+                name: commandName,
+                text: source.slice(current.startIndex, current.endIndex).trim(),
+            });
+        }
+        for (let i = current.namedChildCount - 1; i >= 0; i -= 1) {
+            const child = current.namedChild(i);
+            if (child) {
+                stack.push(child);
+            }
+        }
+    }
+    return details;
+}
+function hasPromptCommandTransform(root) {
+    const stack = [root];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (!current) {
+            continue;
+        }
+        if (current.type === 'expansion') {
+            for (let i = 0; i < current.childCount - 1; i += 1) {
+                const operatorNode = current.child(i);
+                const transformNode = current.child(i + 1);
+                if (operatorNode?.type === '@' &&
+                    transformNode?.text?.toLowerCase() === 'p') {
+                    return true;
+                }
+            }
+        }
+        for (let i = current.namedChildCount - 1; i >= 0; i -= 1) {
+            const child = current.namedChild(i);
+            if (child) {
+                stack.push(child);
+            }
+        }
+    }
+    return false;
+}
+function parseBashCommandDetails(command) {
+    if (treeSitterInitializationError) {
+        throw treeSitterInitializationError;
+    }
+    if (!bashLanguage) {
+        initializeShellParsers().catch(() => {
+            // The failure path is surfaced via treeSitterInitializationError.
+        });
+        return null;
+    }
+    const tree = parseCommandTree(command);
+    if (!tree) {
+        return null;
+    }
+    const details = collectCommandDetails(tree.rootNode, command);
+    return {
+        details,
+        hasError: tree.rootNode.hasError ||
+            details.length === 0 ||
+            hasPromptCommandTransform(tree.rootNode),
+    };
+}
+function parsePowerShellCommandDetails(command, executable) {
+    const trimmed = command.trim();
+    if (!trimmed) {
+        return {
+            details: [],
+            hasError: true,
+        };
+    }
+    try {
+        const result = spawnSync(executable, [
+            '-NoLogo',
+            '-NoProfile',
+            '-NonInteractive',
+            '-EncodedCommand',
+            POWERSHELL_PARSER_SCRIPT,
+        ], {
+            env: {
+                ...process.env,
+                [POWERSHELL_COMMAND_ENV]: command,
+            },
+            encoding: 'utf-8',
+        });
+        if (result.error || result.status !== 0) {
+            return null;
+        }
+        const output = (result.stdout ?? '').toString().trim();
+        if (!output) {
+            return { details: [], hasError: true };
+        }
+        let parsed = null;
+        try {
+            parsed = JSON.parse(output);
+        }
+        catch {
+            return { details: [], hasError: true };
+        }
+        if (!parsed?.success) {
+            return { details: [], hasError: true };
+        }
+        const details = (parsed.commands ?? [])
+            .map((commandDetail) => {
+            if (!commandDetail || typeof commandDetail.name !== 'string') {
+                return null;
+            }
+            const name = normalizeCommandName(commandDetail.name);
+            const text = typeof commandDetail.text === 'string'
+                ? commandDetail.text.trim()
+                : command;
+            return {
+                name,
+                text,
+            };
+        })
+            .filter((detail) => detail !== null);
+        return {
+            details,
+            hasError: details.length === 0,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function parseCommandDetails(command) {
+    const configuration = getShellConfiguration();
+    if (configuration.shell === 'powershell') {
+        return parsePowerShellCommandDetails(command, configuration.executable);
+    }
+    if (configuration.shell === 'bash') {
+        return parseBashCommandDetails(command);
+    }
+    return null;
+}
 /**
  * Determines the appropriate shell configuration for the current platform.
  *
@@ -15,28 +318,23 @@ import { quote } from 'shell-quote';
  */
 export function getShellConfiguration() {
     if (isWindows()) {
-        const comSpec = process.env['ComSpec'] || 'cmd.exe';
-        const executable = comSpec.toLowerCase();
-        if (executable.endsWith('powershell.exe') ||
-            executable.endsWith('pwsh.exe')) {
-            // For PowerShell, the arguments are different.
-            // -NoProfile: Speeds up startup.
-            // -Command: Executes the following command.
-            return {
-                executable: comSpec,
-                argsPrefix: ['-NoProfile', '-Command'],
-                shell: 'powershell',
-            };
+        const comSpec = process.env['ComSpec'];
+        if (comSpec) {
+            const executable = comSpec.toLowerCase();
+            if (executable.endsWith('powershell.exe') ||
+                executable.endsWith('pwsh.exe')) {
+                return {
+                    executable: comSpec,
+                    argsPrefix: ['-NoProfile', '-Command'],
+                    shell: 'powershell',
+                };
+            }
         }
-        // Default to cmd.exe for anything else on Windows.
-        // Flags for CMD:
-        // /d: Skip execution of AutoRun commands.
-        // /s: Modifies the treatment of the command string (important for quoting).
-        // /c: Carries out the command specified by the string and then terminates.
+        // Default to PowerShell for all other Windows configurations.
         return {
-            executable: comSpec,
-            argsPrefix: ['/d', '/s', '/c'],
-            shell: 'cmd',
+            executable: 'powershell.exe',
+            argsPrefix: ['-NoProfile', '-Command'],
+            shell: 'powershell',
         };
     }
     // Unix-like systems (Linux, macOS)
@@ -78,49 +376,11 @@ export function escapeShellArg(arg, shell) {
  * @returns An array of individual command strings
  */
 export function splitCommands(command) {
-    const commands = [];
-    let currentCommand = '';
-    let inSingleQuotes = false;
-    let inDoubleQuotes = false;
-    let i = 0;
-    while (i < command.length) {
-        const char = command[i];
-        const nextChar = command[i + 1];
-        if (char === '\\' && i < command.length - 1) {
-            currentCommand += char + command[i + 1];
-            i += 2;
-            continue;
-        }
-        if (char === "'" && !inDoubleQuotes) {
-            inSingleQuotes = !inSingleQuotes;
-        }
-        else if (char === '"' && !inSingleQuotes) {
-            inDoubleQuotes = !inDoubleQuotes;
-        }
-        if (!inSingleQuotes && !inDoubleQuotes) {
-            if ((char === '&' && nextChar === '&') ||
-                (char === '|' && nextChar === '|')) {
-                commands.push(currentCommand.trim());
-                currentCommand = '';
-                i++; // Skip the next character
-            }
-            else if (char === ';' || char === '&' || char === '|') {
-                commands.push(currentCommand.trim());
-                currentCommand = '';
-            }
-            else {
-                currentCommand += char;
-            }
-        }
-        else {
-            currentCommand += char;
-        }
-        i++;
-    }
-    if (currentCommand.trim()) {
-        commands.push(currentCommand.trim());
+    const parsed = parseCommandDetails(command);
+    if (!parsed || parsed.hasError) {
+        return [];
     }
-    return commands.filter(Boolean); // Filter out any empty strings
+    return parsed.details.map((detail) => detail.text).filter(Boolean);
 }
 /**
  * Extracts the root command from a given shell command string.
@@ -131,36 +391,24 @@ export function splitCommands(command) {
  * @example getCommandRoot("git status && npm test") returns "git"
  */
 export function getCommandRoot(command) {
-    const trimmedCommand = command.trim();
-    if (!trimmedCommand) {
+    const parsed = parseCommandDetails(command);
+    if (!parsed || parsed.hasError || parsed.details.length === 0) {
         return undefined;
     }
-    // This regex is designed to find the first "word" of a command,
-    // while respecting quotes. It looks for a sequence of non-whitespace
-    // characters that are not inside quotes.
-    const match = trimmedCommand.match(/^"([^"]+)"|^'([^']+)'|^(\S+)/);
-    if (match) {
-        // The first element in the match array is the full match.
-        // The subsequent elements are the capture groups.
-        // We prefer a captured group because it will be unquoted.
-        const commandRoot = match[1] || match[2] || match[3];
-        if (commandRoot) {
-            // If the command is a path, return the last component.
-            return commandRoot.split(/[\\/]/).pop();
-        }
-    }
-    return undefined;
+    return parsed.details[0]?.name;
 }
 export function getCommandRoots(command) {
     if (!command) {
         return [];
     }
-    return splitCommands(command)
-        .map((c) => getCommandRoot(c))
-        .filter((c) => !!c);
+    const parsed = parseCommandDetails(command);
+    if (!parsed || parsed.hasError) {
+        return [];
+    }
+    return parsed.details.map((detail) => detail.name).filter(Boolean);
 }
 export function stripShellWrapper(command) {
-    const pattern = /^\s*(?:sh|bash|zsh|cmd.exe)\s+(?:\/c|-c)\s+/;
+    const pattern = /^\s*(?:(?:sh|bash|zsh)\s+-c|cmd\.exe\s+\/c|powershell(?:\.exe)?\s+(?:-NoProfile\s+)?-Command|pwsh(?:\.exe)?\s+(?:-NoProfile\s+)?-Command)\s+/i;
     const match = command.match(pattern);
     if (match) {
         let newCommand = command.substring(match[0].length).trim();
@@ -180,50 +428,6 @@ export function stripShellWrapper(command) {
  * @param command The shell command string to check
  * @returns true if command substitution would be executed by bash
  */
-export function detectCommandSubstitution(command) {
-    let inSingleQuotes = false;
-    let inDoubleQuotes = false;
-    let inBackticks = false;
-    let i = 0;
-    while (i < command.length) {
-        const char = command[i];
-        const nextChar = command[i + 1];
-        // Handle escaping - only works outside single quotes
-        if (char === '\\' && !inSingleQuotes) {
-            i += 2; // Skip the escaped character
-            continue;
-        }
-        // Handle quote state changes
-        if (char === "'" && !inDoubleQuotes && !inBackticks) {
-            inSingleQuotes = !inSingleQuotes;
-        }
-        else if (char === '"' && !inSingleQuotes && !inBackticks) {
-            inDoubleQuotes = !inDoubleQuotes;
-        }
-        else if (char === '`' && !inSingleQuotes) {
-            // Backticks work outside single quotes (including in double quotes)
-            inBackticks = !inBackticks;
-        }
-        // Check for command substitution patterns that would be executed
-        if (!inSingleQuotes) {
-            // $(...) command substitution - works in double quotes and unquoted
-            if (char === '$' && nextChar === '(') {
-                return true;
-            }
-            // <(...) process substitution - works unquoted only (not in double quotes)
-            if (char === '<' && nextChar === '(' && !inDoubleQuotes && !inBackticks) {
-                return true;
-            }
-            // Backtick command substitution - check for opening backtick
-            // (We track the state above, so this catches the start of backtick substitution)
-            if (char === '`' && !inBackticks) {
-                return true;
-            }
-        }
-        i++;
-    }
-    return false;
-}
 /**
  * Checks a shell command against security policies and allowlists.
  *
@@ -249,36 +453,26 @@ export function detectCommandSubstitution(command) {
  * @returns An object detailing which commands are not allowed.
  */
 export function checkCommandPermissions(command, config, sessionAllowlist) {
-    // Disallow command substitution for security.
-    if (detectCommandSubstitution(command)) {
+    const parseResult = parseCommandDetails(command);
+    if (!parseResult || parseResult.hasError) {
         return {
             allAllowed: false,
             disallowedCommands: [command],
-            blockReason: 'Command substitution using $(), <(), or >() is not allowed for security reasons',
+            blockReason: 'Command rejected because it could not be parsed safely',
             isHardDenial: true,
         };
     }
-    const SHELL_TOOL_NAMES = ['run_shell_command', 'ShellTool'];
     const normalize = (cmd) => cmd.trim().replace(/\s+/g, ' ');
-    const isPrefixedBy = (cmd, prefix) => {
-        if (!cmd.startsWith(prefix)) {
-            return false;
-        }
-        return cmd.length === prefix.length || cmd[prefix.length] === ' ';
+    const commandsToValidate = parseResult.details
+        .map((detail) => normalize(detail.text))
+        .filter(Boolean);
+    const invocation = {
+        params: { command: '' },
     };
-    const extractCommands = (tools) => tools.flatMap((tool) => {
-        for (const toolName of SHELL_TOOL_NAMES) {
-            if (tool.startsWith(`${toolName}(`) && tool.endsWith(')')) {
-                return [normalize(tool.slice(toolName.length + 1, -1))];
-            }
-        }
-        return [];
-    });
-    const coreTools = config.getCoreTools() || [];
-    const excludeTools = config.getExcludeTools() || [];
-    const commandsToValidate = splitCommands(command).map(normalize);
     // 1. Blocklist Check (Highest Priority)
-    if (SHELL_TOOL_NAMES.some((name) => excludeTools.includes(name))) {
+    const excludeTools = config.getExcludeTools() || new Set([]);
+    const isWildcardBlocked = SHELL_TOOL_NAMES.some((name) => excludeTools.has(name));
+    if (isWildcardBlocked) {
         return {
             allAllowed: false,
             disallowedCommands: commandsToValidate,
@@ -286,9 +480,11 @@ export function checkCommandPermissions(command, config, sessionAllowlist) {
             isHardDenial: true,
         };
     }
-    const blockedCommands = extractCommands(excludeTools);
     for (const cmd of commandsToValidate) {
-        if (blockedCommands.some((blocked) => isPrefixedBy(cmd, blocked))) {
+        invocation.params['command'] = cmd;
+        if (doesToolInvocationMatch('run_shell_command', invocation, [
+            ...excludeTools,
+        ])) {
             return {
                 allAllowed: false,
                 disallowedCommands: [cmd],
@@ -297,22 +493,24 @@ export function checkCommandPermissions(command, config, sessionAllowlist) {
             };
         }
     }
-    const globallyAllowedCommands = extractCommands(coreTools);
+    const coreTools = config.getCoreTools() || [];
     const isWildcardAllowed = SHELL_TOOL_NAMES.some((name) => coreTools.includes(name));
     // If there's a global wildcard, all commands are allowed at this point
     // because they have already passed the blocklist check.
     if (isWildcardAllowed) {
         return { allAllowed: true, disallowedCommands: [] };
     }
+    const disallowedCommands = [];
     if (sessionAllowlist) {
         // "DEFAULT DENY" MODE: A session allowlist is provided.
         // All commands must be in either the session or global allowlist.
-        const disallowedCommands = [];
+        const normalizedSessionAllowlist = new Set([...sessionAllowlist].flatMap((cmd) => SHELL_TOOL_NAMES.map((name) => `${name}(${cmd})`)));
         for (const cmd of commandsToValidate) {
-            const isSessionAllowed = [...sessionAllowlist].some((allowed) => isPrefixedBy(cmd, normalize(allowed)));
+            invocation.params['command'] = cmd;
+            const isSessionAllowed = doesToolInvocationMatch('run_shell_command', invocation, [...normalizedSessionAllowlist]);
             if (isSessionAllowed)
                 continue;
-            const isGloballyAllowed = globallyAllowedCommands.some((allowed) => isPrefixedBy(cmd, allowed));
+            const isGloballyAllowed = doesToolInvocationMatch('run_shell_command', invocation, coreTools);
             if (isGloballyAllowed)
                 continue;
             disallowedCommands.push(cmd);
@@ -330,11 +528,11 @@ export function checkCommandPermissions(command, config, sessionAllowlist) {
     }
     else {
         // "DEFAULT ALLOW" MODE: No session allowlist.
-        const hasSpecificAllowedCommands = globallyAllowedCommands.length > 0;
+        const hasSpecificAllowedCommands = coreTools.filter((tool) => SHELL_TOOL_NAMES.some((name) => tool.startsWith(`${name}(`))).length > 0;
         if (hasSpecificAllowedCommands) {
-            const disallowedCommands = [];
             for (const cmd of commandsToValidate) {
-                const isGloballyAllowed = globallyAllowedCommands.some((allowed) => isPrefixedBy(cmd, allowed));
+                invocation.params['command'] = cmd;
+                const isGloballyAllowed = doesToolInvocationMatch('run_shell_command', invocation, coreTools);
                 if (!isGloballyAllowed) {
                     disallowedCommands.push(cmd);
                 }
@@ -343,7 +541,9 @@ export function checkCommandPermissions(command, config, sessionAllowlist) {
                 return {
                     allAllowed: false,
                     disallowedCommands,
-                    blockReason: `Command(s) not in the allowed commands list. Disallowed commands: ${disallowedCommands.map((c) => JSON.stringify(c)).join(', ')}`,
+                    blockReason: `Command(s) not in the allowed commands list. Disallowed commands: ${disallowedCommands
+                        .map((c) => JSON.stringify(c))
+                        .join(', ')}`,
                     isHardDenial: false, // This is a soft denial.
                 };
             }
@@ -365,6 +565,28 @@ export function checkCommandPermissions(command, config, sessionAllowlist) {
  * @param config The application configuration.
  * @returns An object with 'allowed' boolean and optional 'reason' string if not allowed.
  */
+export const spawnAsync = (command, args, options) => new Promise((resolve, reject) => {
+    const child = spawn(command, args, options);
+    let stdout = '';
+    let stderr = '';
+    child.stdout.on('data', (data) => {
+        stdout += data.toString();
+    });
+    child.stderr.on('data', (data) => {
+        stderr += data.toString();
+    });
+    child.on('close', (code) => {
+        if (code === 0) {
+            resolve({ stdout, stderr });
+        }
+        else {
+            reject(new Error(`Command failed with exit code ${code}:\n${stderr}`));
+        }
+    });
+    child.on('error', (err) => {
+        reject(err);
+    });
+});
 export function isCommandAllowed(command, config) {
     // By not providing a sessionAllowlist, we invoke "default allow" behavior.
     const { allAllowed, blockReason } = checkCommandPermissions(command, config);
@@ -373,4 +595,50 @@ export function isCommandAllowed(command, config) {
     }
     return { allowed: false, reason: blockReason };
 }
+/**
+ * Determines whether a shell invocation should be auto-approved based on an allowlist.
+ *
+ * This reuses the same parsing logic as command-permission enforcement so that
+ * chained commands must be individually covered by the allowlist.
+ *
+ * @param invocation The shell tool invocation being evaluated.
+ * @param allowedPatterns The configured allowlist patterns (e.g. `run_shell_command(git)`).
+ * @returns True if every parsed command segment is allowed by the patterns; false otherwise.
+ */
+export function isShellInvocationAllowlisted(invocation, allowedPatterns) {
+    if (!allowedPatterns.length) {
+        return false;
+    }
+    const hasShellWildcard = allowedPatterns.some((pattern) => SHELL_TOOL_NAMES.includes(pattern));
+    const hasShellSpecificPattern = allowedPatterns.some((pattern) => SHELL_TOOL_NAMES.some((name) => pattern.startsWith(`${name}(`)));
+    if (!hasShellWildcard && !hasShellSpecificPattern) {
+        return false;
+    }
+    if (hasShellWildcard) {
+        return true;
+    }
+    if (!('params' in invocation) ||
+        typeof invocation.params !== 'object' ||
+        invocation.params === null ||
+        !('command' in invocation.params)) {
+        return false;
+    }
+    const commandValue = invocation.params.command;
+    if (typeof commandValue !== 'string' || !commandValue.trim()) {
+        return false;
+    }
+    const command = commandValue.trim();
+    const parseResult = parseCommandDetails(command);
+    if (!parseResult || parseResult.hasError) {
+        return false;
+    }
+    const normalize = (cmd) => cmd.trim().replace(/\s+/g, ' ');
+    const commandsToValidate = parseResult.details
+        .map((detail) => normalize(detail.text))
+        .filter(Boolean);
+    if (commandsToValidate.length === 0) {
+        return false;
+    }
+    return commandsToValidate.every((commandSegment) => doesToolInvocationMatch(SHELL_TOOL_NAMES[0], { params: { command: commandSegment } }, allowedPatterns));
+}
 //# sourceMappingURL=shell-utils.js.map