> ## Documentation Index
> Fetch the complete documentation index at: https://docs.endorlabs.com/llms.txt
> Use this file to discover all available pages before exploring further.

# toolchains

> Use the toolchains command to detect tools in your repository, create a scan profile, or generate a Dockerfile.

export const Draft = ({children}) => {
  const SHOW_PARAM = 'show';
  const SHOW_VALUE = 'hidden';
  const BORDER_RGB = '220, 38, 38';
  const BORDER_COLOR = '#dc2626';
  const BG_LIGHT = 'rgba(254, 226, 226, 0.65)';
  const BG_DARK = 'rgba(127, 29, 29, 0.35)';
  const HEADER_TEXT_LIGHT = '#111111';
  const HEADER_TEXT_DARK = '#f5f5f5';
  const CARD_MARGIN = '1rem 0';
  const CARD_BORDER_RADIUS = '8px';
  const HEADER_PADDING = '0.75rem 1rem';
  const HEADER_FONT_SIZE = '1.25rem';
  const BODY_PADDING = '0 1rem 0.75rem';
  const ref = useRef(null);
  const [isDark, setIsDark] = useState(false);
  useEffect(() => {
    const checkTheme = () => {
      const root = document.documentElement;
      setIsDark(root.dataset.theme === 'dark' || root.classList.contains('dark'));
    };
    checkTheme();
    const observer = new MutationObserver(checkTheme);
    observer.observe(document.documentElement, {
      attributes: true,
      attributeFilter: ['data-theme', 'class']
    });
    return () => observer.disconnect();
  }, []);
  useEffect(() => {
    if (!ref.current) return;
    const params = new URLSearchParams(globalThis.location.search);
    if (params.get(SHOW_PARAM) === SHOW_VALUE) {
      ref.current.style.display = 'block';
    }
  }, []);
  return <div ref={ref} className="not-prose" style={{
    display: 'none'
  }} role="note" aria-label="Draft internal content">
      <div style={{
    margin: CARD_MARGIN,
    border: `2px solid ${BORDER_COLOR}`,
    borderRadius: CARD_BORDER_RADIUS,
    backgroundColor: isDark ? BG_DARK : BG_LIGHT,
    boxShadow: `0 0 0 1px rgba(${BORDER_RGB}, 0.15) inset`
  }}>
        <div className="not-prose" style={{
    padding: HEADER_PADDING,
    fontWeight: 700,
    fontSize: HEADER_FONT_SIZE,
    color: isDark ? HEADER_TEXT_DARK : HEADER_TEXT_LIGHT,
    textAlign: 'center'
  }}>
          Do not use! Draft content. Development in progress.
        </div>
        <div style={{
    padding: BODY_PADDING
  }}>{children}</div>
      </div>
    </div>;
};

export const YamlTable = ({children, data: propData, content}) => {
  const KV_RE = /^([A-Za-z][A-Za-z0-9_()/#\s-]+?):\s*(.+)$/;
  const INLINE_MD_RE = /(\[([^\]]+)\]\(([^)]+)\))|(`([^`]+)`)|(\*\*([^*]+)\*\*)|(\*([^*]+)\*)/g;
  const YES_RE = /^-yes-$/i;
  const NO_RE = /^-no-$/i;
  const LIMITED_RE = /^-(limited|partial)-$/i;
  const NA_RE = /^-(na|none)-$/i;
  const NA2_RE = /^-na2-$/i;
  const SIMPLE_TAG_RE = /(<br\s*\/?>)|(<p\s*\/?>)|(-note-)|(-warning-)/gi;
  const tryParseKV = trimmed => {
    const m = KV_RE.exec(trimmed);
    return m ? {
      key: m[1],
      value: m[2].trim()
    } : null;
  };
  const registerKey = (key, seenKeys, orderedKeys) => {
    if (!seenKeys.has(key)) {
      orderedKeys.push(key);
      seenKeys.add(key);
    }
  };
  const flushEntry = (currentEntry, entries) => {
    if (Object.keys(currentEntry).length > 0) entries.push(currentEntry);
  };
  const parseDashPrefixed = (lines, entries, orderedKeys, seenKeys) => {
    let currentEntry = {};
    let inEntry = false;
    for (const line of lines) {
      const trimmed = line.trim();
      if (trimmed.startsWith('- ')) {
        if (inEntry) entries.push(currentEntry);
        currentEntry = {};
        inEntry = true;
        const kv = tryParseKV(trimmed.substring(2).trim());
        if (kv) {
          registerKey(kv.key, seenKeys, orderedKeys);
          currentEntry[kv.key] = kv.value;
        }
      } else if (inEntry && trimmed !== '') {
        const kv = tryParseKV(trimmed);
        if (kv) {
          registerKey(kv.key, seenKeys, orderedKeys);
          currentEntry[kv.key] = kv.value;
        }
      }
    }
    flushEntry(currentEntry, entries);
  };
  const parseBlankSeparated = (lines, entries, orderedKeys, seenKeys) => {
    let currentEntry = {};
    let inEntry = false;
    for (const line of lines) {
      const trimmed = line.trim();
      if (trimmed === '') {
        if (inEntry) {
          flushEntry(currentEntry, entries);
          currentEntry = {};
          inEntry = false;
        }
        continue;
      }
      const kv = tryParseKV(trimmed);
      if (!kv) continue;
      const isNewEntry = !line.startsWith(' ') && !line.startsWith('\t');
      if (isNewEntry && inEntry && Object.keys(currentEntry).length > 0) {
        entries.push(currentEntry);
        currentEntry = {};
      }
      registerKey(kv.key, seenKeys, orderedKeys);
      currentEntry[kv.key] = kv.value;
      inEntry = true;
    }
    flushEntry(currentEntry, entries);
  };
  const normalizeEntries = (entries, orderedKeys) => entries.map(entry => {
    const filled = {};
    for (const key of orderedKeys) filled[key] = entry[key] || '';
    return filled;
  });
  const parseYamlTableContent = contentStr => {
    if (!contentStr) return [];
    const entries = [];
    const orderedKeys = [];
    const seenKeys = new Set();
    const lines = contentStr.split('\n');
    if (lines.some(line => line.trim().startsWith('- '))) {
      parseDashPrefixed(lines, entries, orderedKeys, seenKeys);
    } else {
      parseBlankSeparated(lines, entries, orderedKeys, seenKeys);
    }
    return normalizeEntries(entries, orderedKeys);
  };
  const processText = text => {
    if (!text) return text;
    const parts = [];
    let keyIndex = 0;
    let lastIndex = 0;
    let match;
    while ((match = INLINE_MD_RE.exec(text)) !== null) {
      if (match.index > lastIndex) parts.push(text.slice(lastIndex, match.index));
      if (match[1]) {
        parts.push(<a key={keyIndex++} href={match[3]}>{match[2]}</a>);
      } else if (match[4]) {
        parts.push(<code key={keyIndex++}>{match[5]}</code>);
      } else if (match[6]) {
        parts.push(<strong key={keyIndex++}>{match[7]}</strong>);
      } else if (match[8]) {
        parts.push(<em key={keyIndex++}>{match[9]}</em>);
      }
      lastIndex = match.index + match[0].length;
    }
    if (lastIndex < text.length) parts.push(text.slice(lastIndex));
    if (parts.length === 0) return text;
    const keyRef = {
      current: keyIndex
    };
    return expandHtmlTags(parts, keyRef);
  };
  const processBadges = text => {
    if (!text || typeof text !== 'string') return text;
    if (YES_RE.test(text)) return <span className="yt-badge-yes" role="img" aria-label="Supported" title="Supported">✓</span>;
    if (NO_RE.test(text)) return <span className="yt-badge-no" role="img" aria-label="Not supported" title="Not supported">✗</span>;
    if (LIMITED_RE.test(text)) return <span className="yt-badge-limited" role="img" aria-label="Partially supported" title="Partially supported">◐</span>;
    if (NA_RE.test(text) || NA2_RE.test(text)) return <span className="yt-sr-only" title="Not applicable">Not applicable</span>;
    return processText(text);
  };
  const cellClassName = text => {
    if (!text || typeof text !== 'string') return undefined;
    if (NA_RE.test(text)) return 'yt-cell-na';
    if (NA2_RE.test(text)) return 'yt-cell-na2';
    return undefined;
  };
  const expandSimpleTags = (str, keyRef) => {
    const result = [];
    let last = 0;
    SIMPLE_TAG_RE.lastIndex = 0;
    let m;
    while ((m = SIMPLE_TAG_RE.exec(str)) !== null) {
      if (m.index > last) result.push(str.slice(last, m.index));
      if (m[1]) {
        result.push(<br key={keyRef.current++} />);
      } else if (m[2]) {
        result.push(<br key={keyRef.current++} />, <br key={keyRef.current++} />);
      } else if (m[3]) {
        result.push(<span key={keyRef.current++} className="yt-badge-note" style={{
          fontWeight: 600
        }}>Note: </span>);
      } else if (m[4]) {
        result.push(<span key={keyRef.current++} className="yt-badge-warning" style={{
          fontWeight: 600
        }}>Warning: </span>);
      }
      last = m.index + m[0].length;
    }
    if (last < str.length) result.push(str.slice(last));
    return result;
  };
  const expandHtmlTags = (chunks, keyRef) => {
    const out = [];
    for (const chunk of chunks) {
      if (typeof chunk === 'string') {
        out.push(...expandSimpleTags(chunk, keyRef));
      } else {
        out.push(chunk);
      }
    }
    return out;
  };
  const extractText = node => {
    if (node === null || node === undefined) return '';
    if (typeof node === 'string') return node;
    if (typeof node === 'number') return String(node);
    if (typeof node === 'boolean') return '';
    if (Array.isArray(node)) return node.map(extractText).join('');
    if (node && typeof node === 'object' && node.type) {
      const props = node.props || ({});
      if (typeof props.children === 'string') return props.children;
      if (props.children) return extractText(props.children);
      return '';
    }
    return String(node || '');
  };
  const [mounted, setMounted] = useState(false);
  useEffect(() => {
    setMounted(true);
  }, []);
  const data = useMemo(() => {
    if (propData) return propData;
    if (content && typeof content === 'string') return parseYamlTableContent(content);
    if (!children) return [];
    if (typeof children === 'string') return parseYamlTableContent(children);
    const childrenArray = Array.isArray(children) ? children : [children];
    return parseYamlTableContent(childrenArray.map(extractText).join('').trim());
  }, [children, propData, content]);
  const columns = useMemo(() => {
    if (!data || data.length === 0) return [];
    const firstRow = data[0];
    if (!firstRow || typeof firstRow !== 'object') return [];
    return Object.keys(firstRow);
  }, [data]);
  if (!mounted) return null;
  if (!data || data.length === 0) return null;
  const rowKey = row => columns.map(c => row[c] || '').join('|');
  return <table>
      <thead>
        <tr>
          {columns.map(col => <th key={col}>{col.replaceAll('_', ' ')}</th>)}
        </tr>
      </thead>
      <tbody>
        {data.map(row => <tr key={rowKey(row)}>
            {columns.map(col => <td key={col} className={cellClassName(row[col])}>{processBadges(row[col])}</td>)}
          </tr>)}
      </tbody>
    </table>;
};

Use the `endorctl toolchains` command to detect the current tools used in your repository, create a scan profile, or generate a Dockerfile.

<Note>
  Toolchain commands are not supported on Windows.
</Note>

## Usage

* Use the `help` argument to see the options associated with toolchains command.

  ```bash theme={null}
  endorctl toolchains --help
  ```

### Detect tools in your repository

Use `endorctl detect` to identify the tools currently used in your repository.
The following arguments can help you refine your scan:

* Use the `-p` argument to define the local filesystem path to the repository you want to scan.

  ```bash theme={null}
  endorctl toolchains detect -p <path_to_repository>
  ```

* Use the `--exclude-path` argument to exclude specific file paths or directories.

  ```bash theme={null}
  endorctl toolchains detect -p <path_to_repository> --exclude-path 'python/**'
  ```

* Use the `--include-path` argument to limit the scan to a specific file path or directory.

  ```bash theme={null}
  endorctl toolchains detect -p <path_to_repository> --include-path 'development/**'
  ```

### Create a scan profile

Use `endorctl generate` to create a scan profile. See [Configure build tools](/scan/scan-profiles/build-tools) for more details.

* Use the `profile-name` argument to assign a name to your profile. This command creates a `.endorctl/scanprofile.yaml` file with the tools in the repository.

  ```bash theme={null}
  endorctl toolchains generate -p <path_to_repository>  --profile-name <profile-name>
  ```

* Use the `output-type` argument to specify the format of the output file.

  ```bash theme={null}
  endorctl toolchains generate -p <path_to_repository> --profile-name <profile-name> --output-type <output-type>
  ```

* Use the `--output-path` argument to set the output file location.

  ```bash theme={null}
  endorctl toolchains generate -p <path_to_repository> --profile-name <profile-name> --output-type json --output-path <output-path>
  ```

* Use the `--create-profile` argument to create and save the scan profile using the specified options.

  ```bash theme={null}
  endorctl toolchains generate -p <path_to_repository> --profile-name <profile-name> --create-profile
  ```

<Draft>
  **Detect toolchains in your repository and generate a Dockerfile**

  Use `endorctl toolchains docker` to auto detect toolchains and build tools in your repository and generate a Dockerfile pre-configured with endorctl and those tools for scanning your project with Endor Labs. This gives you a working scan environment quickly without manually identifying and installing language toolchains.

  * Navigate to the root of your repository and run the following command to generate a Dockerfile in the current directory.

    ```bash theme={null}
    endorctl toolchains docker
    ```

  * Use the `-p` argument to specify the repository path to scan, and the `-o` argument to set where the Dockerfile is written.

    ```bash theme={null}
    endorctl toolchains docker -p <path_to_repository> -o <output_path>
    ```

  * Use the `-l` or `--languages` argument to limit auto-detection to specific languages.

    ```bash theme={null}
    endorctl toolchains docker -p <path_to_repository> -l <list_of_languages> -o <output_path>
    ```

  * Use the `--include-path` argument to limit toolchain auto detection to specific file paths or directories. The following example limits detection to the `development/` directory and its contents.

    ```bash theme={null}
    endorctl toolchains docker -p <path_to_repository> --include-path 'development/**' -o <output_path>
    ```

  * Use the `--exclude-path` argument to exclude specific paths from toolchain auto detection. The following example excludes the `python/` directory from auto detection.

    ```bash theme={null}
    endorctl toolchains docker -p <path_to_repository> --exclude-path 'python/**' -o <output_path>
    ```
</Draft>

## Options

The `endorctl toolchains` command uses the following flags and environment variables.

<YamlTable>
  {`


    - Flag: \`p\`, \`path\`
    Environment_Variable: \`ENDOR_TOOLCHAINS_PATH\`
    Type: string
    Description: Set the path on the local filesystem to the repository to scan. Default is \`.\`.

    - Flag: \`arch\`
    Environment_Variable: \`ENDOR_TOOLCHAINS_ARCH\`
    Type: string
    Description: Set the toolchain architecture (\`amd64\` or \`arm64\`).

    - Flag: \`os\`
    Environment_Variable: \`ENDOR_TOOLCHAINS_OS\`
    Type: string
    Description: Set the toolchain operating system (\`linux\` or \`darwin\`).

    - Flag: \`exclude-path\`
    Environment_Variable: \`ENDOR_TOOLCHAINS_EXCLUDE_PATH\`
    Type: string
    Description: Specify one or more file paths or directories to exclude from the scan using Glob style expressions. For example, \`src/java/**\` excludes all files under src/java. Paths must be relative to the root of the repository. Use quotes to ensure that your shell does not expand wild cards.

    - Flag: \`include-path\`
    Environment_Variable: \`ENDOR_TOOLCHAINS_INCLUDE_PATH\`
    Type: string
    Description: Limit the scan to the specified file paths or directories using Glob style expressions. For example, \`src/java/**\` includes all files under src/java. Paths must be relative to the root of the repository. Use quotes to ensure that your shell does not expand wild cards.

    - Flag: \`o\`, \`output-path\`
    Environment_Variable: \`ENDOR_TOOLCHAINS_OUTPUT_PATH\`
    Type: string
    Description: Set the output path for the generated scan profile. Used with \`endorctl toolchains generate\`.


    `}
</YamlTable>

<Draft>
  * Flag: `o`, `output-path`
    Environment\_Variable: `ENDOR_TOOLCHAINS_DOCKER_OUTPUT_PATH`
    Type: string
    Description: Set the output path for the generated Dockerfile. Default is `.`. Used with `endorctl toolchains docker`.

  * Flag: `l`, `languages`
    Environment\_Variable: `ENDOR_TOOLCHAINS_LANGUAGES`
    Type: string
    Description: Limit toolchain auto detection to specific languages. Use with `endorctl toolchains docker`.
</Draft>