# CommandSection

title: CAVEATS
content:
<ul><li>The search is performed only against the <i>local</i> npm documentation installed with your npm version. It does not search npm's online documentation or external resources.</li><li>The quality and completeness of results depend on the installed npm version's documentation.</li><li>Results might include internal npm documentation not always relevant to general usage.</li></ul>


title: SEARCH SCOPE
content:
The command searches through all available local npm help topics, including those for commands, configuration, and internal npm functionalities. It matches keywords against both the topic titles and their content.


title: HISTORY
content:
<i>npm-help-search</i> is an integral part of the <i>npm</i> CLI, designed to provide developers with immediate access to documentation. Its functionality has been present for a significant portion of npm's lifecycle, evolving alongside the package manager itself to ensure users can efficiently self-serve their documentation needs. It reflects npm's commitment to comprehensive offline support and user convenience.


title: TLDR
content:
<b>Search for commands or topics related to a keyword</b>`npm help-search [keyword]`<br><b>Search with multiple words</b>`npm help-search [keyword1 keyword2 ...]`


title: TLDR
content:
<b>List all active hooks</b>`npm hook ls`<br><b>Add a new hook for a package</b>`npm hook add [package_name] [event] [target_url]`<br><b>Remove a specific hook by its ID</b>`npm hook rm [hook_id]`<br><b>Update a hook with new information</b>`npm hook update [hook_id] [target_url]`


title: SYNOPSIS
content:
<code><b>npm-install-ci-test</b> [<i>&lt;npm-ci-options&gt;</i>] [-- <i>&lt;npm-test-options&gt;</i>]</code><br><br>This conceptual command typically represents the execution of: <br><code><b>npm ci</b> [<i>&lt;options&gt;</i>] <b>&& npm test</b> [<i>&lt;options&gt;</i>]</code>


title: PARAMETERS
content:
<b>--prefix <path></b><br>&nbsp;&nbsp;&nbsp;&nbsp;<br><i>(Applicable to `npm ci` and `npm test`)</i><br>The folder in which to look for a `package.json` file. Defaults to the current working directory.<br><br><b>--loglevel <level></b><br>&nbsp;&nbsp;&nbsp;&nbsp;<br><i>(Applicable to `npm ci` and `npm test`)</i><br>What level of logs to output. Possible values: `silent`, `error`, `warn`, `info`, `http`, `verbose`, `silly`.<br><br><b>--json</b><br>&nbsp;&nbsp;&nbsp;&nbsp;<br><i>(Applicable to `npm test`)</i><br>Outputs test results in JSON format, useful for programmatic consumption in CI systems.<br><br><b>--no-audit</b><br>&nbsp;&nbsp;&nbsp;&nbsp;<br><i>(Applicable to `npm ci`)</i><br>Disables the audit step when installing dependencies. This can speed up installation but bypasses security checks.<br><br><b>--ignore-scripts</b><br>&nbsp;&nbsp;&nbsp;&nbsp;<br><i>(Applicable to `npm ci` and `npm test`)</i><br>Disables the execution of `pre/post` scripts defined in `package.json`. Useful for security or performance in specific CI scenarios.<br><br><b>--force</b><br>&nbsp;&nbsp;&nbsp;&nbsp;<br><i>(Applicable to `npm ci`)</i><br>Forces the installation of dependencies, even if `package-lock.json` is missing or corrupted. Generally not recommended for CI due to potential inconsistencies.<br><br>


title: DESCRIPTION
content:
The `npm-install-ci-test` command represents a common pattern or custom script used primarily in Continuous Integration (CI) and Continuous Delivery (CD) environments for Node.js projects. Its core function is to first ensure that all project dependencies are installed in a clean and consistent manner, and then to execute the project's defined test suite. While not a standalone command shipped with `npm` itself, it encapsulates the crucial steps of setting up a build environment for a Node.js application and verifying its functionality.<br><br>The "ci" in its name emphasizes the use of `<b>npm ci</b>` for dependency installation, which is optimized for CI environments to provide speed, consistency, and reliability by strictly adhering to the `package-lock.json` or `npm-shrinkwrap.json` file. Following a successful installation, `npm-install-ci-test` proceeds to run the `<b>npm test</b>` command, which executes the scripts defined under the "test" property in the project's `package.json` file. This sequence is fundamental for automated quality assurance, ensuring that any new code changes or deployments do not introduce regressions and that the application remains functional.


title: CAVEATS
content:
<ul><li><b>`package-lock.json` Requirement</b>: `<b>npm ci</b>` requires a `package-lock.json` or `npm-shrinkwrap.json` file to be present. If it's missing, `<b>npm ci</b>` will fail, ensuring consistent installs.</li><li><b>Clean State</b>: `<b>npm ci</b>` removes any existing `node_modules` directory before installing. This ensures a clean slate, but can be slower if `node_modules` already contains necessary packages from a previous run (though this is typically desired in CI).</li><li><b>Network Dependency</b>: Both `<b>npm ci</b>` and `<b>npm test</b>` (if tests involve network requests or external resources) depend on network connectivity to fetch packages or external data.</li><li><b>Resource Usage</b>: Running tests can be CPU and memory intensive, especially for large projects, potentially impacting build agent performance in CI.</li><li><b>Test Flakiness</b>: Tests themselves can be flaky, leading to intermittent failures not caused by code changes. `npm-install-ci-test` will report these as failures.</li></ul>


title: `NPM INSTALL` VS. `NPM CI`
content:
While `<b>npm install</b>` is commonly used for local development, `<b>npm ci</b>` (clean install) is the recommended command for CI environments.<br><br><code><b>npm install</b></code>: Installs dependencies from `package.json`, updating `package-lock.json` if necessary. It attempts to resolve new compatible versions if `package-lock.json` is outdated or missing. It reuses existing `node_modules` if possible.<br><br><code><b>npm ci</b></code>: Strictly installs dependencies exactly as specified in `package-lock.json`. It <i>requires</i> `package-lock.json` to exist, and it <i>deletes</i> `node_modules` before installing to ensure a fresh, consistent environment. It's faster for repeat installs and ensures identical dependency trees across environments.


title: HISTORY
content:
The `npm-install-ci-test` pattern emerged with the increasing adoption of Continuous Integration and the need for reliable and reproducible builds in Node.js projects. Prior to `<b>npm ci</b>`, developers often used `<b>npm install</b>` in CI, which could lead to inconsistencies if `package-lock.json` wasn't strictly honored or if `node_modules` wasn't cleaned properly. The introduction of `<b>npm ci</b>` in `npm` version 5.7.0 (January 2018) specifically addressed these CI challenges, providing a faster, more consistent, and more reliable way to install dependencies. This led to the formalization of the `<b>npm ci && npm test</b>` sequence, often encapsulated in custom scripts or CI pipeline configurations, effectively giving rise to the "npm-install-ci-test" concept as a best practice for automated project validation.


title: TLDR
content:
<b>Install dependencies and run tests</b>`npm [[cit|install-ci-test]]`<br><b>Display detailed logs during installation and testing</b>`npm [[cit|install-ci-test]] --verbose`


title: PARAMETERS
content:
<b>[no arguments]</b><br>&nbsp;&nbsp;&nbsp;&nbsp;When run inside a package's root directory, this command creates a global symbolic link pointing to that package. This makes the package globally available to be linked into other projects.<br><br><b>&lt;package-name&gt;</b><br>&nbsp;&nbsp;&nbsp;&nbsp;When run inside a consuming project's root directory, this command creates a local symbolic link within its <i>node_modules</i> folder, pointing to the globally-linked package specified by <i>&lt;package-name&gt;</i>.<br><br><b>&lt;package-folder&gt;</b><br>&nbsp;&nbsp;&nbsp;&nbsp;When run inside a consuming project's root directory, this command creates a local symbolic link within its <i>node_modules</i> folder, directly pointing to the specified local <i>&lt;package-folder&gt;</i> without requiring global registration.<br><br>


title: DESCRIPTION
content:
The <b>npm link</b> command is a powerful utility within the npm ecosystem designed to facilitate local development and testing of npm packages. It establishes a symbiotic relationship between a local package and other projects that depend on it, without the need for publishing the package to a registry. Essentially, it uses symbolic links (symlinks) to connect a package's source directory directly into a project's <i>node_modules</i> folder.<br><br>This mechanism is particularly useful for developers working on multiple interdependent modules. Instead of constantly reinstalling a local package after every change, <b>npm link</b> allows for instantaneous updates. When changes are made in the linked package, they are immediately reflected in the consuming project, significantly streamlining the development workflow.<br><br><b>npm link</b> operates in two primary modes: first, by globally registering a package (run <b>npm link</b> in the package's root directory), and second, by linking that globally registered package into a consuming project (run <b>npm link &lt;package-name&gt;</b> in the project's root). It can also directly link a local folder using <b>npm link &lt;path-to-folder&gt;</b>. The inverse operation, <b>npm unlink</b>, removes these symbolic links.


title: CAVEATS
content:
Creating symbolic links, especially on Windows, may require elevated administrator privileges or enabling Developer Mode.<br><br>While excellent for development, <b>npm link</b> is not intended for production deployments. It can sometimes lead to issues with conflicting dependency versions if the linked package and the consuming project have different versions of shared dependencies, or with peer dependency resolution.<br><br>Always use <b>npm unlink</b> to clean up the symlinks when done, otherwise, your global <i>node_modules</i> or local <i>node_modules</i> might point to non-existent or outdated paths.


title: UNDERLYING MECHANISM
content:
When you run <i>npm link</i> in a package, npm creates a symlink in a global location (typically <i>/usr/local/lib/node_modules/&lt;package-name&gt;</i> on Unix-like systems, or <i>%AppData%\npm\node_modules\&lt;package-name&gt;</i> on Windows). When you run <i>npm link &lt;package-name&gt;</i> in another project, npm creates a symlink from that project's <i>node_modules/&lt;package-name&gt;</i> to the global symlink, which then points to your original package source. This dual-symlink approach ensures a consistent linking process.


title: WINDOWS OS BEHAVIOR
content:
On Windows, creating symbolic links is a privileged operation. If you encounter permissions errors, ensure you are running your terminal as an administrator, or enable Developer Mode in Windows settings. Alternatively, some setups might use directory junctions for folders, which have slightly different permissions requirements.


title: HISTORY
content:
The <b>npm link</b> command has been a fundamental feature of the Node.js package manager since its early days. It emerged as an essential tool to address the common challenge of developing and testing multiple interconnected npm packages locally. As the modularization trend in JavaScript and Node.js ecosystems grew, the need for an efficient way to iterate on dependent packages without publishing them for every minor change became paramount, solidifying <b>npm link</b>'s role as a core development utility.


title: TLDR
content:
<b>Symlink the current package globally</b>`npm link`<br><b>Link a globally linked package into another project's node_modules</b>`npm link [package_name]`<br><b>Unlink a package from the current project</b>`npm unlink [package_name]`


title: TLDR
content:
<b>Create a tarball from the current package in the current directory</b>`npm pack`<br><b>Create a tarball from a specific package folder</b>`npm pack [path/to/package_directory]`<br><b>Run a dry run to preview the tarball contents without creating it</b>`npm pack --dry-run`<br><b>Create a tarball without running lifecycle scripts</b>`npm pack --ignore-scripts`<br><b>Specify a custom registry to fetch package metadata from</b>`npm pack --registry [https://registry.npmjs.org/]`


title: SYNOPSIS
content:
npm ping [<b>--registry=&lt;url&gt;</b>] [<b>--json</b>] [<b>--loglevel=&lt;level&gt;</b>] [<b>-s</b>|<b>--silent</b>]


title: PARAMETERS
content:
<b><b>--registry=&lt;url&gt;</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specifies an alternative registry URL to ping instead of the default or configured one. This allows testing connectivity to specific registries.<br><br><b><b>--json</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Outputs the command's results in a structured JSON format, useful for scripting and programmatic parsing of the ping status.<br><br><b><b>--loglevel=&lt;level&gt;</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Sets the verbosity of <i>npm</i> output. Common levels include <i>silent</i>, <i>error</i>, <i>warn</i>, <i>notice</i>, <i>http</i>, <i>info</i>, <i>verbose</i>, and <i>silly</i>. Affects how much detail is shown during the ping operation.<br><br><b><b>-s</b>, <b>--silent</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Runs the command in silent mode, suppressing progress bars and most informational messages, showing only errors or final results.<br><br>


title: DESCRIPTION
content:
The <b>npm ping</b> command, a subcommand of the Node Package Manager (npm) CLI, is a crucial utility for verifying the operational status and user authentication against the configured npm registry. When executed, it sends an authenticated <i>GET</i> request to the <i>/~/ping</i> endpoint of the active registry.<br><br>A successful response indicates that the npm CLI can reach the registry and, if logged in, that the user's authentication token is valid. This command is particularly useful for diagnosing network issues, confirming registry availability, or troubleshooting authentication problems before attempting package installations or publications. Its primary function is to provide a quick, lightweight check, returning either a success message, potentially with user details if authenticated, or an error if connectivity or authentication fails. It helps developers confirm their environment is correctly configured to interact with the npm ecosystem.


title: CAVEATS
content:
The <b>npm ping</b> command, being a subcommand of the primary <i>npm</i> CLI, relies heavily on a functional <i>npm</i> installation and active network connectivity to the target registry. While it verifies authentication, this check is only meaningful if the user is currently logged in via <b>npm login</b>. It does not validate specific package availability or the health of individual registry services beyond the <i>/~/ping</i> endpoint. Users should also be aware that proxy configurations or corporate firewalls can interfere with its operation, even if general internet access is available.


title: OUTPUT FORMAT
content:
By default, <b>npm ping</b> outputs a human-readable success or error message. When the <b>--json</b> option is used, it returns a JSON object containing <i>ok: true</i> or <i>false</i>, and potentially user information if authenticated successfully (e.g., <i>user: { name: 'your-username' }</i>).


title: REGISTRY CONFIGURATION
content:
The command respects the currently configured <i>registry</i> setting, which can be found using <b>npm config get registry</b>. This can be overridden for a single command execution using the <b>--registry=&lt;url&gt;</b> flag.


title: HISTORY
content:
The <b>npm ping</b> command was introduced as a core utility within the Node Package Manager (npm) CLI to address the frequent need for users to quickly ascertain their connection status to the npm registry. Its development was driven by the common troubleshooting scenarios involving network issues, registry outages, or authentication token expirations.<br><br>By providing a standardized endpoint (<i>/~/ping</i>) for health checks, it offered a more robust alternative to attempting a dummy <b>npm install</b> for connection verification. It has remained a stable and foundational command, reflecting the <i>npm</i> team's commitment to providing clear diagnostic tools for developers working within the npm ecosystem.


title: TLDR
content:
<b>Ping the default npm registry</b>`npm ping`<br><b>Ping custom npm registry</b>`npm ping --registry [custom_registry_url]`


title: SYNOPSIS
content:
<i><code>npm pack</code></i><br><i><code>npm pack &lt;package-spec&gt;...</code></i><br><i><code>npm pack [--dry-run] [--json] [--pack-destination &lt;dir&gt;]</code></i>


title: PARAMETERS
content:
<b><i><code>--dry-run</code></i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Shows what files would be included in the tarball without actually creating it.<br><br><b><i><code>--json</code></i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Outputs data in JSON format, useful for programmatic consumption.<br><br><b><i><code>--pack-destination &lt;dir&gt;</code></i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specifies the directory where the tarball should be saved. Defaults to the current working directory.<br><br><b><i><code>--foreground-scripts</code></i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Runs <i><code>prepack</code></i>, <i><code>pack</code></i>, and <i><code>postpack</code></i> scripts in the foreground.<br><br><b><i><code>--ignore-scripts</code></i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Prevents the execution of <i><code>prepack</code></i>, <i><code>pack</code></i>, and <i><code>postpack</code></i> lifecycle scripts.<br><br><b><i><code>--workspace &lt;name&gt;</code></i>, <i><code>--workspaces</code></i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Used within monorepos to specify a particular workspace or operate on all workspaces.<br><br><b><i><code>--include-workspace-root</code></i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;When used with <i><code>--workspaces</code></i>, includes the root package of the monorepo in the operation.<br><br>


title: DESCRIPTION
content:
<i><code>npm pack</code></i> creates a compressed tarball (<i><code>.tgz</code></i> file) of an npm package, allowing for easy distribution, installation, or local testing without publishing to a registry. It takes into account the <i><code>files</code></i> field in <i><code>package.json</code></i> and respects <i><code>.npmignore</code></i> (or <i><code>.gitignore</code></i> if <i><code>.npmignore</code></i> is absent) to determine which files to include. This command is invaluable for developers who need to share a package with others for testing, or to prepare a package for publication to a private or public registry.<br><br>The resulting tarball contains all the necessary code and <i><code>package.json</code></i> metadata, making it self-contained and ready for installation via <i><code>npm install &lt;tarball-file&gt;</code></i>. It also executes <i><code>prepack</code></i> and <i><code>postpack</code></i> scripts if defined in <i><code>package.json</code></i>.


title: CAVEATS
content:
It is assumed that <i>"npm-pkg"</i> refers to the <i><code>npm pack</code></i> command, as <i><code>npm-pkg</code></i> is not a standard Linux command or a direct subcommand of <i><code>npm</code></i>.<br><br>The <i><code>npm pack</code></i> command does not publish the package; it only prepares the tarball. The behavior regarding included and excluded files is crucial and depends heavily on <i><code>package.json</code></i>'s <i><code>files</code></i> array and the presence of <i><code>.npmignore</code></i> or <i><code>.gitignore</code></i> files.


title: EXCLUDING FILES
content:
<i><code>npm pack</code></i> automatically excludes certain files and directories like <i><code>.git</code></i>, <i><code>CVS</code></i>, <i><code>.svn</code></i>, <i><code>.hg</code></i>, <i><code>node_modules</code></i>, <i><code>.npmignore</code></i>, <i><code>README.md</code></i> (and other readme formats), <i><code>CHANGES.md</code></i>, and <i><code>LICENSE.md</code></i> unless explicitly included. If a <i><code>.npmignore</code></i> file is present in the package root, its rules override <i><code>.gitignore</code></i>. If no <i><code>.npmignore</code></i> is present, <i><code>.gitignore</code></i> is used.


title: PACKAGE LIFECYCLE SCRIPTS
content:
<i><code>npm pack</code></i> triggers <i><code>prepack</code></i> and <i><code>postpack</code></i> lifecycle scripts defined in <i><code>package.json</code></i>. <i><code>prepack</code></i> runs before the tarball is generated, often used for compilation or preprocessing. <i><code>postpack</code></i> runs after the tarball is created.


title: HISTORY
content:
The <i><code>npm</code></i> CLI, and with it the <i><code>npm pack</code></i> command, has been an integral part of the Node.js ecosystem since its inception. npm was first released in 2010 by Isaac Schlueter. The ability to <i><code>pack</code></i> a module into a tarball has always been fundamental for local testing, offline distribution, and preparing packages for publication, preceding the more recent additions of features like workspaces. Its design reflects the UNIX philosophy of creating small, composable tools, with <i><code>pack</code></i> serving as a critical step in the software supply chain for Node.js modules.


title: TLDR
content:
<b>Get the value of a specific property</b>`npm pkg get [name]`<br><b>Get multiple properties at once</b>`npm pkg get [name|version|...]`<br><b>Get multiple values across all workspaces</b>`npm pkg get [name] [version] [[--ws|--workspaces]]`<br><b>Get a nested or array property value</b>`npm pkg get [contributors[0].email]`<br><b>Set a property to a specific value</b>`npm pkg set [property]=[value]`<br><b>Set multiple properties at once</b>`npm pkg set [property1]=[value1] [property2]=[value2]`<br><b>Delete a property from package.json</b>`npm pkg delete [scripts.build]`<br><b>Auto-fix common errors in package.json</b>`npm pkg fix`


title: SYNOPSIS
content:
<b>npm profile get</b> [<I>username</I>]<br><b>npm profile set</b> <I>&lt;field&gt;</I> <I>&lt;value&gt;</I><br><b>npm profile enable-2fa</b> [--otp <I>&lt;otpcode&gt;</I>]<br><b>npm profile disable-2fa</b> [--otp <I>&lt;otpcode&gt;</I>]<br><b>npm profile set password</b><br><b>npm profile set email</b> <I>&lt;email&gt;</I>


title: PARAMETERS
content:
<b><b>get</b> [<I>username</I>]</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Retrieves profile information for the specified user or the currently logged-in user if <I>username</I> is omitted.<br><br><b><b>set</b> <I>&lt;field&gt;</I> <I>&lt;value&gt;</I></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Updates a specific profile field (e.g., <I>email</I>, <I>password</I>) with a new value. Invoking <I>set password</I> or <I>set email</I> without a <I>value</I> will lead to an interactive prompt.<br><br><b><b>enable-2fa</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Initiates the process to enable two-factor authentication (2FA) for the current account. This typically involves an interactive setup or requires an <I>--otp</I> flag.<br><br><b><b>disable-2fa</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Disables two-factor authentication (2FA) for the current account. This operation usually requires an <I>--otp</I> or interactive confirmation.<br><br><b><b>--otp</b> <I>&lt;otpcode&gt;</I></b><br>&nbsp;&nbsp;&nbsp;&nbsp;A one-time password from an authenticator app, required for certain 2FA-related operations (e.g., <i>enable-2fa</i>, <i>disable-2fa</i>, or when publishing if 2FA is enabled).<br><br>


title: DESCRIPTION
content:
The <b>npm profile</b> command allows users to interact with and manage their profile details on the npm registry. This includes viewing profile information, updating details like email and password, and configuring two-factor authentication (2FA). It is a crucial tool for maintaining the security and accuracy of an npm account, directly interfacing with the npm public registry or a private registry.<br><br>It centralizes commands for retrieving, setting, and securing user-specific information on the npm registry, providing a comprehensive interface for personalizing and protecting one's presence in the npm ecosystem.


title: CAVEATS
content:
1. <b>Authentication Required:</b> You must be logged in to npm using <i>npm login</i> to use most <b>npm profile</b> commands.<br>2. <b>Interactive Prompts:</b> Sensitive operations, such as changing your password or managing 2FA, often involve interactive terminal prompts to confirm your identity and securely collect information.<br>3. <b>Registry-Specific Changes:</b> All modifications made via <b>npm profile</b> directly affect your account on the npm registry (public or private), not your local npm client configuration.<br>4. <b>Network Connectivity:</b> A stable internet connection is essential for <b>npm profile</b> to communicate with the npm registry.


title: INTERACTIVE PROMPTS FOR SECURITY OPERATIONS
content:
For critical security-related operations, such as changing your password with <b>npm profile set password</b> or enabling 2FA, <b>npm profile</b> often employs interactive prompts. These prompts ensure that the user is intentionally performing sensitive actions and provide a secure way to input credentials or confirm changes directly in the terminal.


title: TWO-FACTOR AUTHENTICATION (2FA) MANAGEMENT
content:
The <b>npm profile</b> command is the authoritative tool for managing Two-Factor Authentication (2FA) on your npm account. Enabling 2FA through <b>enable-2fa</b> adds an essential layer of security, requiring a time-based one-time password (TOTP) for various sensitive actions, including publishing packages and altering profile settings. Disabling 2FA is handled via <b>disable-2fa</b>.


title: HISTORY
content:
The <b>npm profile</b> command has been an integral part of the npm CLI, evolving alongside the package manager itself. Its capabilities expanded significantly with the increasing focus on user account security within the npm ecosystem. The introduction and integration of two-factor authentication (2FA) support, particularly with the dedicated <b>enable-2fa</b> and <b>disable-2fa</b> subcommands, marked a crucial development, establishing it as the primary interface for managing this critical security feature for npm accounts. Its continuous development reflects the npm community's commitment to providing robust and secure tools for developers.


title: TLDR
content:
<b>View the npm profile details</b>`npm profile get`<br><b>View a specific property of the profile</b>`npm profile get [property]`<br><b>Set or update a profile property</b>`npm profile set [property] [value]`<br><b>Set the public email address</b>`npm profile set email [email]`<br><b>Set the public name</b>`npm profile set fullname [name]`<br><b>Set a new password interactively</b>`npm profile set password`<br><b>Enable two-factor authentication (2FA) (defaults to auth-and-writes)</b>`npm profile enable-2fa [auth-only|auth-and-writes]`<br><b>Disable two-factor authentication (2FA)</b>`npm profile disable-2fa`


title: SYNOPSIS
content:
<b><br>npm prune</b> [<path>]<br><b><br>npm prune</b> --production<br><b><br>npm prune</b> --dry-run


title: PARAMETERS
content:
<b><b><br>[<path>]</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Optional path to the project directory where <b><br>npm prune</b> should be executed. Defaults to the current working directory.<br><br><b><b><br>--production</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Removes <i><br>devDependencies</i> (packages listed in <i><br>devDependencies</i> in <i><br>package.json</i>) from the <i><br>node_modules</i> directory, treating them as unnecessary. Only production dependencies will remain.<br><br><b><b><br>--dry-run</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Performs a simulated run, showing which packages would be pruned without actually modifying the <i><br>node_modules</i> directory. Useful for previewing changes.<br><br><b><b><br>--json</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Outputs the list of pruned packages in JSON format to standard output. Useful for programmatic parsing.<br><br><b><b><br>--omit <type></b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Prevents pruning of specific dependency types. For example, <b><br>--omit=dev</b> will keep <i><br>devDependencies</i>, effectively similar to not using <b><br>--production</b>.<br><br>


title: DESCRIPTION
content:
The <b><br>npm prune</b> command cleans up your <i><br>node_modules</i> directory by removing packages that are not listed as dependencies in your <i><br>package.json</i> file, or are not required by your <i><br>package-lock.json</i> (if present). Its primary purpose is to free up disk space and ensure that your project's dependencies are minimal and strictly adhere to what's defined in your project's manifest. This is especially useful in production environments or CI/CD pipelines where you want to deploy only essential runtime dependencies, excluding development-specific packages. <br><br>When executed, <b><br>npm prune</b> compares the contents of your <i><br>node_modules</i> directory against the dependencies defined in <i><br>package.json</i> and <i><br>package-lock.json</i>, identifying and deleting any packages that are extraneous. This can include manually installed packages, outdated versions that didn't get removed during an update, or <i><br>devDependencies</i> when the <i><br>--production</i> flag is used. It helps maintain a clean and consistent dependency tree, preventing potential issues arising from lingering, unmanaged packages.


title: CAVEATS
content:
<b><br>npm prune</b> only removes packages from <i><br>node_modules</i>; it <i><br>does not</i> modify your <i><br>package.json</i> or <i><br>package-lock.json</i> files. If you've manually removed a dependency from your <i><br>package.json</i>, running <b><br>npm prune</b> will remove its corresponding files, but it won't prevent it from being reinstalled if another package depends on it implicitly or if your <i><br>package-lock.json</i> still lists it as a dependency for some reason. Always ensure your <i><br>package.json</i> reflects your desired dependencies before pruning. It can also be a slow operation for very large <i><br>node_modules</i> folders.


title: USAGE IN CI/CD
content:
<b><br>npm prune</b> is frequently used in Continuous Integration/Continuous Deployment (CI/CD) pipelines after <b><br>npm install</b>. The typical flow involves running <b><br>npm install</b> to get all dependencies, then running <b><br>npm prune --production</b> to remove development-only dependencies before building and deploying the application. This minimizes the size of the deployment artifact and potential attack surface in production.


title: IMPLICIT PRUNING WITH NPM INSTALL
content:
It's important to note that <b><br>npm install</b> often performs an implicit pruning operation when a <i><br>package-lock.json</i> file is present. If the contents of <i><br>node_modules</i> do not match the state described in <i><br>package-lock.json</i>, <b><br>npm install</b> will attempt to bring it into line, which can include removing extraneous packages. However, <b><br>npm prune</b> provides a dedicated and explicit command for this cleanup task, offering more control with its specific options.


title: HISTORY
content:
The <b><br>npm prune</b> command has been a fundamental part of the <i><br>npm</i> CLI since its early versions, addressing the common need to manage the often extensive <i><br>node_modules</i> directory. Its evolution has been tied to the growing complexity of JavaScript project dependencies and the emphasis on lean deployment artifacts. Initially, its role was straightforward cleanup, but with the introduction of <i><br>package-lock.json</i> and more sophisticated dependency resolution, <b><br>npm prune</b> gained a more precise mechanism for identifying truly extraneous packages, ensuring consistency across environments.


title: TLDR
content:
<b>Remove all extraneous packages not listed in dependencies</b>`npm prune`<br><b>Remove extraneous packages and devDependencies (useful for production builds)</b>`npm prune --production`<br><b>Show what would be removed without making any changes</b>`npm prune --dry-run`<br><b>Output the changes as JSON</b>`npm prune --json`<br><b>Remove specific packages by name</b>`npm prune [package_name]`


title: TLDR
content:
<b>Publish the current package to the default npm registry</b>`npm publish`<br><b>Publish a package from a specific directory</b>`npm publish [path/to/package_directory]`<br><b>Publish a scoped package with public access</b>`npm publish --access public`<br><b>Publish a scoped package with restricted (private) access</b>`npm publish --access restricted`<br><b>Publish a package to a custom registry</b>`npm publish --registry [https://registry.npmjs.org/]`<br><b>Run a dry run to see what would be published without uploading</b>`npm publish --dry-run`<br><b>Publish a package with a specific distribution tag (e.g., beta)</b>`npm publish --tag [beta]`<br><b>Publish with a one-time password for 2FA-enabled accounts</b>`npm publish --otp [one_time_password]`


title: TLDR
content:
<b>Rebuild a specific package</b>`npm [[rb|rebuild]] [package]`<br><b>Rebuild all installed packages</b>`npm [[rb|rebuild]]`<br><b>Rebuild with verbose output</b>`npm [[rb|rebuild]] --verbose`<br><b>Rebuild a package in a specific directory</b>`npm [[rb|rebuild]] --prefix [path/to/dir] [package]`<br><b>Rebuild without using the npm cache</b>`npm [[rb|rebuild]] --no-cache`<br><b>Rebuild in global mode</b>`npm [[rb|rebuild]] [[-g|--global]]`


title: PARAMETERS
content:
<b><package-name></b><br>&nbsp;&nbsp;&nbsp;&nbsp;The name of the `npm` package whose repository URL should be opened. If this argument is omitted, `npm` attempts to open the repository for the package in the current working directory, using its `package.json` file.<br><br>


title: DESCRIPTION
content:
The `<b>npm repo</b>` command is a subcommand of the Node Package Manager (`npm`) used to open the source code repository of an `npm` package in the default web browser.<br><br>When executed without a package name, it opens the repository for the current project, as defined by the `repository` field in its `package.json` file. If a <i>&lt;package-name&gt;</i> is provided, it retrieves the `repository` URL for that specific package from the `npm` registry and attempts to open it.<br><br>This command is a convenient way for developers to quickly navigate to a package's source code, facilitating contributions, issue tracking, or detailed code exploration without manually searching for the repository link. It relies on the system's default browser-opening mechanism, such as `xdg-open` on Linux, `open` on macOS, or `start` on Windows.


title: CAVEATS
content:
<ul><li>`<b>npm repo</b>` relies on the `repository` field being correctly specified in the `package.json` file of the package in question, either locally or in the `npm` registry.</li><li>A default web browser must be installed and properly configured on the system for the command to function successfully.</li><li>If the `repository` field is missing or malformed, or if a browser cannot be launched, the command will fail or print an error message.</li></ul>


title: NOTE ON COMMAND NAMING
content:
The command analyzed here is `<b>npm repo</b>`, a standard subcommand of the Node Package Manager. Although the prompt used `<b>npm-repo</b>`, there is no standard Linux command or `npm` subcommand with that hyphenated name. It is highly probable that `<b>npm-repo</b>` was a typo or a colloquial reference to `<b>npm repo</b>`.


title: CONFIGURATION
content:
While `<b>npm repo</b>` itself has no specific flags, it respects general `npm` configuration options that might affect how it resolves package names or interacts with the registry (e.g., `--registry`, `--prefix`). However, these are not directly applicable to its core function of opening a repository URL.


title: HISTORY
content:
The `<b>npm repo</b>` command was introduced as part of the `npm` CLI to provide quick access to a package's source code repository. It streamlines the workflow for developers by abstracting away the need to manually locate and copy repository URLs, aligning with `npm`'s goal of simplifying package management and discovery. Its functionality is closely related to other `npm` commands like `<b>npm home</b>` and `<b>npm docs</b>`, which provide similar shortcuts to other package-related web resources.


title: TLDR
content:
<b>Open the repository page of the current project (based on package.json)</b>`npm repo`<br><b>Open the repository page of a specific package from the registry</b>`npm repo [package_name]`<br><b>Open repository pages for multiple packages</b>`npm repo [package_name1 package_name2 ...]`<br><b>Print the repository URL instead of opening it in the browser</b>`npm repo --browser false`<br><b>Open the repository page for a package in a specific browser</b>`npm repo --browser [browser_name]`<br><b>Open the repository page of a package in a specific workspace</b>`npm repo --workspace [workspace_name]`


title: SYNOPSIS
content:
<b>npm shrinkwrap</b> [<i>&lt;options&gt;</i>]<br><i>This command is executed as an npm subcommand. It typically does not accept direct arguments after the subcommand itself.</i>


title: PARAMETERS
content:
<b><i>None</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;The <b>npm shrinkwrap</b> command itself does not accept any specific options or arguments directly. Its behavior is primarily determined by the current state of <i>node_modules</i> and <i>package.json</i>, or by general <i>npm</i> configuration settings.<br><br>


title: DESCRIPTION
content:
<i>npm-shrinkwrap</i> is an <i>npm</i> command that creates an <i>npm-shrinkwrap.json</i> file in your project's root directory. This file records the exact version of every dependency and sub-dependency used by your project at the time the shrinkwrap file was created. The primary goal is to ensure reproducible installations across different environments.<br><br>When <i>npm install</i> is run in a project containing <i>npm-shrinkwrap.json</i>, it will use the versions specified in that file rather than resolving new versions from <i>package.json</i>. While <i>npm-shrinkwrap.json</i> was once the primary mechanism for locking dependencies, it has largely been superseded by <i>package-lock.json</i> since <i>npm@5</i>.<br><br>However, <i>npm-shrinkwrap.json</i> still serves a specific purpose, particularly when publishing a package where you want its <b>consumers</b> to install the <b>exact</b> dependency tree you've tested, rather than allowing their <i>package-lock.json</i> to override it.


title: CAVEATS
content:
<b>Limitations and Caveats:</b><br><i>npm-shrinkwrap.json</i> is largely superseded by <i>package-lock.json</i> for application development.<br>It is only recommended if you need to enforce a specific dependency tree for <b>consumers</b> of your <b>published package</b>.<br>Can lead to confusion or conflicts if both <i>npm-shrinkwrap.json</i> and <i>package-lock.json</i> exist, as <i>npm-shrinkwrap.json</i> takes precedence.<br>Does not currently support <i>npm</i> workspaces for locking dependencies across projects within a monorepo.


title: PURPOSE OF <I>NPM-SHRINKWRAP.JSON</I> VS. <I>PACKAGE-LOCK.JSON</I>
content:
<b>npm-shrinkwrap.json</b> is typically used for <b>published packages</b> where you want to dictate the exact dependency tree for consumers. When publishing, if <i>npm-shrinkwrap.json</i> exists, it will be included in the published package, overriding any <i>package-lock.json</i> a consumer might have for the same dependencies.<br><br><b>package-lock.json</b> is primarily for <b>applications</b> to ensure reproducible installs for developers and CI/CD, and it is generally <b>not published</b> with a library.


title: CREATION AND USAGE
content:
The <b>npm shrinkwrap</b> command creates the <i>npm-shrinkwrap.json</i> file based on the current <i>node_modules</i> tree. <b>npm install</b> then uses this file to perform installations, ensuring that the exact versions specified in the shrinkwrap file are installed.<br><br>If both <i>npm-shrinkwrap.json</i> and <i>package-lock.json</i> are present in a project, <i>npm-shrinkwrap.json</i> takes precedence for dependency resolution during <i>npm install</i>.


title: HISTORY
content:
The <b>npm shrinkwrap</b> command was introduced in <b>npm@2</b> to provide deterministic dependency installations, addressing the "dependency hell" problem where different installations could lead to varying versions of sub-dependencies. It became the recommended way to lock dependencies for applications, ensuring that builds were reproducible.<br><br>However, with <b>npm@5</b>, <i>package-lock.json</i> was introduced as the default and preferred mechanism, generated automatically by <i>npm install</i>. <i>package-lock.json</i> addressed some limitations of <i>npm-shrinkwrap.json</i>, such as better diffing and more consistent integration with <i>package.json</i> for all installations.<br><br>Today, <i>npm-shrinkwrap.json</i> primarily serves a specific, advanced use case for package <b>publishers</b> who wish to strictly control the dependency tree of their published package, explicitly overriding potential <i>package-lock.json</i> files on the consumer side.


title: TLDR
content:
<b>Generate a npm-shrinkwrap.json file from the current package-lock.json</b>`npm shrinkwrap`<br><b>Run in production mode (excludes devDependencies)</b>`npm shrinkwrap --production`<br><b>Force recreate the shrinkwrap file even if it already exists</b>`npm shrinkwrap --force`


title: TLDR
content:
<b>Fetch an access token using client credentials</b>`oauth2c [issuer_url] --client-id [client_id] --client-secret [client_secret]`<br><b>Fetch a token using authorization code flow</b>`oauth2c [issuer_url] --client-id [client_id] --response-types code`<br><b>Fetch a token using authorization code with PKCE</b>`oauth2c [issuer_url] --client-id [client_id] --pkce`<br><b>Fetch a token using password credentials</b>`oauth2c [issuer_url] --client-id [client_id] --username [username] --password [password]`<br><b>Refresh an existing access token</b>`oauth2c [issuer_url] --client-id [client_id] --refresh-token [refresh_token]`<br><b>Fetch a token with specific scopes</b>`oauth2c [issuer_url] --client-id [client_id] --scopes [scope1,scope2]`<br><b>Use device authorization flow</b>`oauth2c [issuer_url] --client-id [client_id] --grant-type device_code`<br><b>Run in silent mode without browser</b>`oauth2c [issuer_url] --client-id [client_id] [[-s|--silent]] --no-browser`


title: PARAMETERS
content:
<b>--format=<I>FORMAT</I></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specifies the output format of the build. Valid values are <B>sdist</B> (source distribution), <B>wheel</B> (built distribution), or <B>all</B> (both). The default is <B>all</B>.<br><br><b>--no-interaction</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Do not ask any interactive questions during the build process, assuming default answers.<br><br><b>--config=<I>CONFIG</I></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specifies an alternative configuration file to use for the build.<br><br><b>-v, --verbose</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Increase the verbosity of messages. Use <B>-v</B> for normal output, <B>-vv</B> for more verbose output, and <B>-vvv</B> for debug output.<br><br><b>-q, --quiet</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Do not output any messages, silencing the command's output.<br><br><b>--ansi</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Force ANSI output, even if the terminal does not appear to support it.<br><br><b>--no-ansi</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Disable ANSI output, preventing color and other ANSI escape codes.<br><br><b>--no-plugins</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Disable the loading of Poetry plugins during the command execution.<br><br><b>--no-cache</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Disable the cache for the build process, forcing a fresh build.<br><br><b>--clean</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Remove the build directory (<I>dist/</I> by default) before starting the build process.<br><br><b>--allow-prereleases</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Allow the usage of prerelease versions when resolving dependencies for the build.<br><br><b>-h, --help</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Display help information for the <I>build</I> command.<br><br><b>-V, --version</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Display the Poetry application version.<br><br>


title: DESCRIPTION
content:
<b><I>poetry build</I></b> is a core command within the Poetry dependency manager for Python. Its primary function is to create distributable packages for a Python project. This includes a source distribution (<I>.tar.gz</I>) and a built distribution, commonly known as a wheel file (<I>.whl</I>). These packages are essential for sharing a Python library or application with others, allowing them to install it easily using tools like <I>pip</I>.<br><br>The command automatically reads the project's metadata from the <I>pyproject.toml</I> file, including dependencies, version, and entry points, to correctly package the project. It ensures that the built artifacts adhere to Python packaging standards (PEP 517/518) and are ready for publishing to package indexes like PyPI. By default, it builds both formats, but this can be controlled via options.


title: CAVEATS
content:
<ul><li>Requires a valid <I>pyproject.toml</I> file at the project root with at least the <I>[tool.poetry]</I> section defining project metadata.</li><li>The built artifacts are placed in a <I>dist/</I> directory by default, created in the project root.</li><li>For projects with specific file inclusion/exclusion needs, ensure these are correctly configured using the <I>include</I> and <I>exclude</I> directives in <I>pyproject.toml</I>.</li><li>If a custom build backend is specified (e.g., using <I>build-system.build-backend</I> in <I>pyproject.toml</I>), that backend will be invoked instead of Poetry's internal builder.</li></ul>


title: BUILD ARTIFACTS
content:
<b><I>poetry build</I></b> produces two main types of distribution artifacts:<br><br>1. <I>Source Distribution</I> (<B>sdist</B>): A compressed archive (e.g., <I>.tar.gz</I>) containing the source code and metadata needed to build the package from scratch. It is platform-independent.<br><br>2. <I>Wheel Distribution</I> (<B>wheel</B>): A pre-built distribution archive (e.g., <I>.whl</I>) that can be installed directly without needing to run any build steps. Wheels are generally faster to install and can be platform-specific or universal.<br><br>Both are placed in a <I>dist/</I> directory by default, ready for installation or publishing.


title: PACKAGING STANDARDS
content:
Poetry's <I>build</I> command adheres to modern Python packaging standards outlined in <B>PEP 517</B> (A build system independent way of specifying source package builds) and <B>PEP 518</B> (Specifying build system dependencies for source trees). This adherence ensures broad interoperability with other Python tools and build systems, making packages built with Poetry compatible with the wider Python ecosystem.


title: HISTORY
content:
Poetry was initially released around late 2017/early 2018 as an alternative to existing Python dependency management and packaging tools. The <I>build</I> command has been a fundamental part of Poetry since its early versions, providing the capability to create standard Python distribution artifacts. Its implementation evolved to align with <B>PEP 517</B> and <B>PEP 518</B>, ensuring compatibility with modern Python packaging standards and allowing it to serve as a comprehensive build system for Python projects.


title: TLDR
content:
<b>Build a tarball and a wheel for the project</b>`poetry build`<br><b>Build a wheel package</b>`poetry build [[-f|--format]] wheel`<br><b>Build a source distribution (sdist)</b>`poetry build [[-f|--format]] sdist`<br><b>Clean the output directory before building</b>`poetry build --clean`<br><b>Set the output directory</b>`poetry build [[-o|--output]] [path/to/directory]`


title: PARAMETERS
content:
<b>--help, -h</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Display help for the <b>shell</b> command.<br><br><b>--quiet, -q</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Do not output any message.<br><br><b>--verbose, -v</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Increase the verbosity of messages (e.g., <i>-v</i>, <i>-vv</i>, <i>-vvv</i>).<br><br><b>--directory, -C <path></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Change the current working directory to the specified path. This allows running <b>poetry shell</b> from outside the project root if the path points to a <b>poetry</b> project.<br><br><b>--ansi</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Force ANSI output.<br><br><b>--no-ansi</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Disable ANSI output.<br><br><b>--no-interaction, -n</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Do not ask any interactive question.<br><br>


title: DESCRIPTION
content:
The <b>poetry-shell</b> command is a subcommand of the <b>poetry</b> tool, a modern and comprehensive dependency manager for Python projects. Its primary function is to activate a new shell instance within the context of the current project's virtual environment. This command provides a seamless way to work with project-specific dependencies without polluting the global Python environment or requiring manual activation steps.<br><br>When <b>poetry-shell</b> is executed, it first ensures that a virtual environment exists for the project. If one doesn't exist, <b>poetry</b> often prompts to create it or suggests running <b>poetry install</b>. Once the environment is ready, <b>poetry-shell</b> spawns a new shell (e.g., bash, zsh, cmd.exe) where the virtual environment is automatically activated. This means that any Python or pip commands executed within this new shell will operate on the project's isolated dependencies and Python interpreter. This isolation is crucial for reproducible builds and avoiding dependency conflicts across multiple projects.<br><br>Developers can then run development scripts, tests, or application code using the exact Python version and libraries specified in their <b>pyproject.toml</b> file. To exit the activated shell, simply type <b>exit</b>. This command significantly enhances the developer experience by ensuring a consistent and isolated workspace for each Python project managed by <b>poetry</b>.


title: CAVEATS
content:
<ul><li>Requires <b>poetry</b> to be installed on the system.</li><li>Must be executed within a <b>poetry</b>-managed project directory, or with the <i>-C</i> option pointing to one.</li><li>If a virtual environment for the project does not exist, <b>poetry</b> might prompt the user to create one (e.g., by running <b>poetry install</b>).</li><li>The command starts a new sub-shell. Exiting this sub-shell (e.g., with <b>exit</b>) returns to the parent shell.</li><li>Does not *create* the virtual environment itself; it activates an existing or implicitly created one. For explicit creation, use <b>poetry install</b>.</li></ul>


title: HOW IT WORKS
content:
When <b>poetry shell</b> is run, <b>poetry</b> first locates the project's <b>pyproject.toml</b> file to identify the virtual environment associated with it. If no virtual environment exists, <b>poetry</b> typically creates one automatically (or prompts the user if configured otherwise). Once the environment is located or created, <b>poetry</b> then executes a new shell process (e.g., <i>bash</i>, <i>zsh</i>, <i>cmd.exe</i>) and, crucially, configures this new shell's environment variables (like <i>PATH</i>) to point to the virtual environment's Python interpreter and scripts. This ensures that any subsequent Python-related commands run within this specific shell session will use the project's isolated dependencies.


title: EXITING THE SHELL
content:
To leave the activated <b>poetry</b> shell and return to your original shell environment, simply type <b>exit</b> and press <i>Enter</i>. This will terminate the sub-shell process that <b>poetry shell</b> initiated.


title: HISTORY
content:
The <b>poetry</b> project was initiated by Sébastien Eustace in 2017 with the goal of providing a comprehensive and opinionated dependency manager for Python, inspired by tools like <i>npm</i> and <i>yarn</i> from the JavaScript ecosystem. It aimed to address common frustrations with <b>pip</b>, <b>setuptools</b>, and traditional <b>virtualenv</b> workflows, especially regarding dependency resolution and project packaging.<br><br>The <b>poetry-shell</b> command is an integral part of <b>poetry</b>'s design philosophy, emphasizing isolated development environments. From its early versions, <b>poetry</b> integrated virtual environment management directly, and <b>poetry-shell</b> provided a user-friendly abstraction over manually activating these environments. This command has been a stable feature, central to <b>poetry</b>'s promise of making Python project development more streamlined and less error-prone by ensuring developers always work within the correct dependency context.


title: TLDR
content:
<b>List resource alarms</b>`rabbitmq-diagnostics alarms`<br><b>List node certificates</b>`rabbitmq-diagnostics certificates`<br><b>Check if RabbitMQ is running on the specified node</b>`rabbitmq-diagnostics check_running --node [node]`<br><b>Run peer discovery</b>`rabbitmq-diagnostics discover_peers`<br><b>List listeners (bound sockets)</b>`rabbitmq-diagnostics listeners`<br><b>Print the last n log lines on the specified node</b>`rabbitmq-diagnostics log_tail --number [n] --node [node]`


title: SYNOPSIS
content:
<b>rabbitmq-plugins</b> [-n <i>&lt;node&gt;</i>] [-l <i>&lt;log_level&gt;</i>] [--online | --offline] &lt;command&gt; [plugin ...] [options]


title: PARAMETERS
content:
<b><b>-n</b> <i>&lt;node&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specifies the RabbitMQ node name (e.g., <i>rabbit@hostname</i>). Defaults to <i>rabbit@localhost</i>.<br><br><b><b>-l</b> <i>&lt;log_level&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Sets the log level for <b>rabbitmq-plugins</b> itself (e.g., <i>info</i>, <i>warning</i>, <i>error</i>).<br><br><b><b>--online</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Explicitly indicates that the command should operate with the RabbitMQ node running. This is the default.<br><br><b><b>--offline</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Indicates that the command should operate with the RabbitMQ node stopped. Essential for certain plugin operations.<br><br><b><b>--silent</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Suppresses most informational output.<br><br><b><b>--verbose</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Produces more verbose output.<br><br><b><b>--json</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Formats output as JSON (primarily for the <b>list</b> command).<br><br><b><b>list</b> [<i>-E &lt;regexp&gt;</i>] [<i>-m &lt;mode&gt;</i>] [<i>--silent</i>] [<i>--verbose</i>] [<i>--json</i>]</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Lists installed plugins.<br><i>-E &lt;regexp&gt;</i>: Filters plugins by a regular expression.<br><i>-m &lt;mode&gt;</i>: Filters by plugin mode (<i>enabled</i>, <i>disabled</i>, <i>all</i>).<br><br><b><b>enable</b> <i>&lt;plugin&gt;</i> [...<i>&lt;plugin&gt;</i>] [<i>--offline</i>] [<i>--silent</i>]</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Enables one or more specified plugins.<br><br><b><b>disable</b> <i>&lt;plugin&gt;</i> [...<i>&lt;plugin&gt;</i>] [<i>--offline</i>] [<i>--silent</i>]</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Disables one or more specified plugins.<br><br><b><b>install</b> <i>&lt;plugin&gt;</i> [...<i>&lt;plugin&gt;</i>] [<i>--online</i>] [<i>--silent</i>]</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Installs one or more specified plugins, making them available to the broker.<br><br><b><b>remove</b> <i>&lt;plugin&gt;</i> [...<i>&lt;plugin&gt;</i>] [<i>--online</i>] [<i>--silent</i>]</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Removes one or more specified plugins, making them unavailable to the broker.<br><br><b><b>update</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Updates plugin metadata cache. (Less common, usually for specific scenarios).<br><br><b><b>debug</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Displays various debug information about plugins and the plugin loader.<br><br>


title: DESCRIPTION
content:
The <b>rabbitmq-plugins</b> command-line tool is an essential utility for managing plugins on a RabbitMQ broker node. Plugins extend the core functionality of RabbitMQ, providing features such as the management UI, MQTT and STOMP protocol adapters, federation, shovels, and more.<br>This command allows administrators to list available plugins, enable or disable specific plugins, install new ones, and remove existing ones. It interacts directly with the RabbitMQ server, either online (when the server is running) or offline (when the server is stopped, requiring the <b>--offline</b> flag). Proper use of <b>rabbitmq-plugins</b> is crucial for customizing and enhancing a RabbitMQ deployment to meet specific messaging requirements.


title: CAVEATS
content:
Most <b>enable</b> and <b>disable</b> operations require the RabbitMQ node to be stopped if dependencies are not met or if the plugin significantly alters the runtime environment; in such cases, use the <b>--offline</b> flag.<br>Changes made using <b>rabbitmq-plugins</b> often require a restart of the RabbitMQ node to take full effect.<br>Enabling or disabling a plugin can have dependency implications. The command will attempt to resolve and warn about missing dependencies or dependent plugins that will also be affected.<br>Running <b>rabbitmq-plugins</b> may require elevated privileges (e.g., <b>sudo</b>) depending on the system's user permissions for the RabbitMQ installation directories and runtime files.


title: PLUGIN DEPENDENCIES
content:
RabbitMQ plugins can have dependencies on other plugins. When enabling a plugin, <b>rabbitmq-plugins</b> will automatically attempt to enable its dependencies. If a required dependency is missing or cannot be enabled, the operation will fail with an informative error message. Similarly, disabling a plugin might affect other plugins that depend on it.


title: PLUGIN LOCATION
content:
RabbitMQ plugins are typically distributed as <i>.ez</i> files (Erlang Zip archives). These files are placed in a designated plugins directory, which RabbitMQ scans for available plugins. The <b>install</b> and <b>remove</b> commands often interact with this directory, though manual placement is also possible. The default location can vary by installation method but is commonly found under <i>/usr/lib/rabbitmq/lib/rabbitmq_server-&lt;version&gt;/plugins/</i> or similar paths.


title: HISTORY
content:
The <b>rabbitmq-plugins</b> command has been an integral part of the RabbitMQ distribution since its early days, evolving alongside the broker's plugin architecture. Initially, plugins were managed through configuration files or by directly manipulating the <i>plugins</i> directory. The command-line tool streamlined this process, providing a consistent and robust interface for administrators.<br>Significant developments include the introduction of the <b>--offline</b> flag, which greatly simplified plugin management in clustered or production environments by allowing safe operations on stopped nodes, and the addition of JSON output for easier integration with automation scripts and monitoring tools. Its design reflects the growing complexity and extensibility of the RabbitMQ ecosystem.


title: TLDR
content:
<b>List plugins</b>`rabbitmq-plugins list`<br><b>Enable a plugin</b>`rabbitmq-plugins enable [plugin]`<br><b>Disable a plugin</b>`rabbitmq-plugins disable [plugin]`<br><b>Enable a plugin and disable the rest</b>`rabbitmq-plugins set [plugin]`


title: TLDR
content:
<b>Grow quorum queue clusters by adding a member on the specified node</b>`rabbitmq-queues grow [node] [all|even]`<br><b>Rebalance leaders of replicated queues across nodes</b>`rabbitmq-queues rebalance [all|quorum|stream]`<br><b>Shrink quorum queue clusters by removing any members on the specified node</b>`rabbitmq-queues shrink [node]`<br><b>Add a quorum queue member on the specified node</b>`rabbitmq-queues add_member [queue] [node]`<br><b>Delete a quorum queue member on the specified node</b>`rabbitmq-queues delete_member [queue] [node]`<br><b>Display quorum status of a quorum queue</b>`rabbitmq-queues quorum_status [queue]`


title: TLDR
content:
<b>Add a stream replica on the specified node</b>`rabbitmq-streams add_replica [stream] [node]`<br><b>Delete a stream replica on the specified node</b>`rabbitmq-streams delete_replica [stream] [node]`<br><b>Display the status of a stream</b>`rabbitmq-streams stream_status [stream]`<br><b>Restart a stream</b>`rabbitmq-streams restart_stream [stream]`<br><b>List stream connections</b>`rabbitmq-streams list_stream_connections`<br><b>List all stream consumers</b>`rabbitmq-streams list_stream_consumers`<br><b>List all stream publishers</b>`rabbitmq-streams list_stream_publishers`<br><b>List tracking information for a stream</b>`rabbitmq-streams list_stream_tracking [stream]`


title: PARAMETERS
content:
<b><b>status</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Checks the current upgrade status of the node, reporting if an upgrade is in progress, pending, or complete.<br><br><b><b>drain</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Stops all RabbitMQ applications on the node, but keeps the Erlang VM running. This is a preparatory step for upgrades, allowing the node to gracefully stop processing messages without fully shutting down.<br><br><b><b>perform_upgrade</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Executes the actual upgrade process. This command performs data migrations, converts necessary files, and prepares the node for the new RabbitMQ version. It should be run after `drain` and installing the new RabbitMQ package.<br><br><b><b>cleanup_reboot</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Performs cleanup tasks after an upgrade, which might include removing old data files or finalizing the upgrade state. It's often used if `perform_upgrade` didn't complete a full cleanup or after a system reboot.<br><br><b><b>forget_upgrade</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Resets the node's upgrade state, effectively telling RabbitMQ to forget about any pending or failed upgrade attempts. Use with caution, typically when reverting to an older version or retrying a failed upgrade.<br><br><b><b>list_unsupported_versions</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Lists all nodes in a cluster that are running versions incompatible with a direct upgrade path to the target version, helping to identify potential issues in multi-node environments.<br><br><b><b>--timeout <I>seconds</I></b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Sets a timeout for the upgrade operation in seconds. If the operation exceeds this time, it will be aborted.<br><br><b><b>--description <I>text</I></b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Adds a user-defined description to the upgrade event, which can be useful for logging and tracking upgrade history.<br><br>


title: DESCRIPTION
content:
The <b>rabbitmq-upgrade</b> command facilitates the process of upgrading a RabbitMQ server node, particularly when moving between major or minor versions that require data format changes or other significant migrations. It's designed to manage the delicate state transitions during an upgrade, ensuring data consistency and minimizing manual intervention. The command typically stops RabbitMQ applications, performs necessary data conversions or schema migrations, and then restarts the applications.<br><br>It's a critical component of the RabbitMQ upgrade toolkit, intended to be run after a new version of RabbitMQ is installed but before the server is fully started. While `rabbitmq-upgrade` automates many steps, users must always consult the official RabbitMQ upgrade guide for their specific version path, as preparatory steps, Erlang/OTP compatibility, and cluster upgrade strategies are crucial and often vary.


title: CAVEATS
content:
Always <b>backup your RabbitMQ data directory</b> before attempting any upgrade.<br>Consult the official RabbitMQ upgrade guide for your specific version path; instructions often vary significantly between major versions (e.g., 3.x to 4.x).<br>Ensure Erlang/OTP version compatibility with the new RabbitMQ version.<br>Cluster upgrades require careful planning; refer to the documentation for rolling upgrade strategies.<br>Downtime is typically required for a single-node upgrade and often for cluster upgrades as well.<br>Monitor system resources (disk space, memory) during the upgrade process.


title: TYPICAL SINGLE-NODE UPGRADE PROCESS
content:
A common single-node upgrade sequence involves these high-level steps:<br>1. Stop the existing RabbitMQ service.<br>2. Install the new RabbitMQ package.<br>3. Run `rabbitmq-upgrade drain`.<br>4. Run `rabbitmq-upgrade perform_upgrade`.<br>5. Start the new RabbitMQ service.<br>6. (Optional) Run `rabbitmq-upgrade cleanup_reboot` if needed.<br>Always verify these steps with the official guide for your specific version.


title: CLUSTER UPGRADES CONSIDERATIONS
content:
Upgrading a RabbitMQ cluster requires a more coordinated approach. It typically involves either a full cluster shutdown and upgrade, or a rolling upgrade where nodes are upgraded one by one, minimizing total downtime. The `list_unsupported_versions` command is particularly useful for planning cluster upgrades and identifying potential roadblocks before starting the process.


title: HISTORY
content:
The `rabbitmq-upgrade` command has been an integral part of the RabbitMQ ecosystem for managing version transitions. Its functionality has evolved with RabbitMQ itself, becoming more robust to handle complex data migrations and ensure compatibility across significant architectural changes, such as those introduced in RabbitMQ 3.x and 4.x series. It centralizes the upgrade logic, reducing the need for manual file manipulations and intricate step-by-step procedures that were more common in very early versions.


title: TLDR
content:
<b>Wait for all quorum queues to have an above minimum online quorum</b>`rabbitmq-upgrade await_online_quorum_plus_one`<br><b>Put the node in maintenance mode</b>`rabbitmq-upgrade drain`<br><b>Put the node out of maintenance and into regular operating mode</b>`rabbitmq-upgrade revive`<br><b>Run post-upgrade tasks</b>`rabbitmq-upgrade post_upgrade`<br><b>Display help</b>`rabbitmq-upgrade help`


title: SYNOPSIS
content:
<pre><code><b>rpk</b> [<i>global-options</i>] <i>command</i> [<i>command-options</i>] [<i>arguments</i>]</code></pre><br>Common top-level commands include:<br><br><pre><code><b>rpk</b> cluster <i>...</i><br><b>rpk</b> topic <i>...</i><br><b>rpk</b> group <i>...</i><br><b>rpk</b> acl <i>...</i><br><b>rpk</b> config <i>...</i><br><b>rpk</b> profile <i>...</i><br><b>rpk</b> container <i>...</i><br><b>rpk</b> producer <i>...</i><br><b>rpk</b> consumer <i>...</i></code></pre>


title: PARAMETERS
content:
<b><i>--help, -h</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Show help for the command or subcommand.<br><br><b><i>--version</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Show the <b>rpk</b> client version.<br><br><b><i>--config &lt;path&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Path to the <b>rpk</b> configuration file (e.g., <i>rpk.yaml</i>). Defaults to <i>~/.config/rpk/rpk.yaml</i>.<br><br><b><i>--profile &lt;name&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;The <b>rpk</b> profile to use from the configuration file, allowing for easy switching between different cluster connections.<br><br><b><i>--api-urls &lt;urls&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Comma-separated list of URLs to the Redpanda Admin API (e.g., <i>http://localhost:9644</i>), used for administrative tasks.<br><br><b><i>--brokers &lt;urls&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Comma-separated list of URLs to the Redpanda Kafka API (e.g., <i>localhost:9092</i>), used for producing/consuming messages and Kafka-compatible operations.<br><br><b><i>--user &lt;username&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Username for SASL authentication when connecting to brokers.<br><br><b><i>--password &lt;password&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Password for SASL authentication when connecting to brokers.<br><br><b><i>--sasl-mechanism &lt;mechanism&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;SASL mechanism to use (e.g., <i>SCRAM-SHA-256</i>, <i>PLAIN</i>).<br><br><b><i>--tls-enabled</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Enable TLS encryption when connecting to brokers.<br><br><b><i>--tls-truststore &lt;path&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Path to the CA certificate file for TLS validation.<br><br><b><i>--verbose</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Enable verbose output, providing more detailed information during command execution.<br><br><b><i>--debug</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Enable debug logging, which outputs extensive diagnostic information.<br><br>


title: DESCRIPTION
content:
The <b>rpk</b> command is the primary command-line interface for interacting with Redpanda, a Kafka-compatible, C++ based streaming data platform designed for high performance and low latency. It provides comprehensive tools for managing Redpanda clusters, including administering topics, consumer groups, users, and Access Control Lists (ACLs). <b>rpk</b> allows developers and operators to perform tasks such as creating and deleting topics, producing and consuming messages, inspecting cluster health, and managing cluster configurations. It's an indispensable tool for development, debugging, and day-to-day operations of Redpanda deployments, whether on bare metal, virtual machines, or Kubernetes. Its hierarchical subcommand structure makes it versatile for a wide range of administrative and data-centric tasks, simplifying complex streaming data operations.


title: CAVEATS
content:
<ul><li>Requires a running Redpanda cluster or a containerized Redpanda instance that is network-reachable from where <b>rpk</b> is executed.</li><li>Operations like topic creation or user management require appropriate administrative privileges (ACLs) configured within the Redpanda cluster.</li><li>Network connectivity between the <b>rpk</b> client and the Redpanda cluster's Admin API and Kafka API ports is essential for all operations.</li><li>The <i>--api-urls</i> and <i>--brokers</i> flags, or a correctly configured <i>rpk.yaml</i> file, are crucial for <b>rpk</b> to establish connections to the cluster.</li></ul>


title: SUBCOMMANDS OVERVIEW
content:
<i>rpk</i> utilizes a rich subcommand structure to organize its functionalities. For instance, `<b>rpk topic</b>` handles all topic-related operations (create, delete, list, describe), `<b>rpk cluster</b>` provides cluster-wide information and management (health, config), and `<b>rpk acl</b>` manages access control lists for users and resources. Each subcommand often has its own set of options and sub-subcommands, allowing for granular control over Redpanda resources and their attributes.


title: CONFIGURATION
content:
<i>rpk</i> can be configured via a YAML file, typically named <i>rpk.yaml</i>, located in <i>~/.config/rpk/</i> or specified by the <i>--config</i> flag. This file allows users to define connection parameters, authentication credentials, and profiles for different Redpanda clusters, simplifying command invocation by avoiding repetitive flag inputs. Environment variables can also be used to override configuration settings, providing flexibility in deployment environments.


title: HISTORY
content:
The <b>rpk</b> command was developed by Vectorized (now Redpanda Data) as the native command-line interface for the Redpanda streaming data platform. Redpanda was conceived as a high-performance, C++ alternative to Apache Kafka, prioritizing ease of operations and enterprise-grade features. From its inception, <b>rpk</b> has been an integral part of the Redpanda ecosystem, designed to provide a comprehensive and intuitive way to manage and interact with Redpanda clusters. Its development has closely tracked the evolution of Redpanda itself, incorporating new features and optimizations to simplify cluster administration, development workflows, and debugging processes for users.


title: SEE ALSO
content:
kafka-topics.sh (Kafka CLI for topic management), kafka-consumer-groups.sh (Kafka CLI for consumer group management), kubectl (1) (Kubernetes command-line tool, relevant when Redpanda is deployed on Kubernetes), docker (1) (Container management tool, relevant for `rpk container` commands)


title: TLDR
content:
<b>Create a new topic</b>`rpk topic create [topic_name]`<br><b>Produce a message to a topic</b>`rpk topic produce [topic_name]`<br><b>Consume messages from multiple topics</b>`rpk topic consume [topic_name1 topic_name2 ...]`<br><b>List all topics</b>`rpk topic list`<br><b>Display cluster information</b>`rpk cluster info`<br><b>List all consumer groups</b>`rpk group list`<br><b>Describe a consumer group with lag information</b>`rpk group describe [group_name]`<br><b>Display version</b>`rpk version`


title: SYNOPSIS
content:
<b>trafilatura</b> [<I>OPTIONS</I>] [<I>URL_OR_PATH</I>]<br><b>trafilatura</b> --url <I>URL</I> [<I>OPTIONS</I>]<br><b>trafilatura</b> --file <I>PATH</I> [<I>OPTIONS</I>]<br><b>trafilatura</b> --crawl <I>URL</I> [<I>OPTIONS</I>]


title: PARAMETERS
content:
<b>--url <URL></b><br>&nbsp;&nbsp;&nbsp;&nbsp;<i>Specify a URL to process directly.</i><br><br><b>--file <PATH></b><br>&nbsp;&nbsp;&nbsp;&nbsp;<i>Process an HTML file from the local filesystem.</i><br><br><b>--crawl <URL></b><br>&nbsp;&nbsp;&nbsp;&nbsp;<i>Initiate a basic crawl starting from the given URL.</i><br><br><b>--json</b><br>&nbsp;&nbsp;&nbsp;&nbsp;<i>Output the extracted content and metadata as JSON.</i><br><br><b>--xml</b><br>&nbsp;&nbsp;&nbsp;&nbsp;<i>Output the extracted content and metadata as XML.</i><br><br><b>--csv</b><br>&nbsp;&nbsp;&nbsp;&nbsp;<i>Output the extracted content and metadata as CSV (for lists of items).</i><br><br><b>--output <PATH></b><br>&nbsp;&nbsp;&nbsp;&nbsp;<i>Specify an output file path for the extracted content.</i><br><br><b>--config <PATH></b><br>&nbsp;&nbsp;&nbsp;&nbsp;<i>Load a custom configuration file.</i><br><br><b>--keep-empty</b><br>&nbsp;&nbsp;&nbsp;&nbsp;<i>Keep empty fields in the output.</i><br><br><b>--no-comments</b><br>&nbsp;&nbsp;&nbsp;&nbsp;<i>Do not extract comments from the webpage.</i><br><br><b>--no-images</b><br>&nbsp;&nbsp;&nbsp;&nbsp;<i>Exclude images from the extracted content.</i><br><br><b>--no-soup</b><br>&nbsp;&nbsp;&nbsp;&nbsp;<i>Skip BeautifulSoup cleanup, useful for malformed HTML.</i><br><br><b>--links</b><br>&nbsp;&nbsp;&nbsp;&nbsp;<i>Extract only the links found on the page.</i><br><br><b>--silent</b><br>&nbsp;&nbsp;&nbsp;&nbsp;<i>Suppress progress messages and warnings.</i><br><br><b>--verbose</b><br>&nbsp;&nbsp;&nbsp;&nbsp;<i>Enable verbose output for debugging.</i><br><br><b>--help</b><br>&nbsp;&nbsp;&nbsp;&nbsp;<i>Display a help message and exit.</i><br><br><b>--version</b><br>&nbsp;&nbsp;&nbsp;&nbsp;<i>Show program's version number and exit.</i><br><br>


title: DESCRIPTION
content:
<i><b>trafilatura</b></i> is a powerful and versatile Python library designed for robust web content extraction. It provides a command-line interface (CLI) that allows users to effortlessly extract the main content, metadata (like author, date, title), and comments from web pages. Its primary goal is to simplify the process of retrieving clean, structured data from HTML, handling common issues such as boilerplate content, advertisements, and navigation elements. It supports various input methods, including direct URLs, local HTML files, and even basic crawling capabilities, offering output in multiple formats like JSON, XML, and plain text. This makes <i><b>trafilatura</b></i> an invaluable tool for data journalists, researchers, and developers working with web-sourced information.


title: CAVEATS
content:
<i><b>trafilatura</b></i> is a Python library and thus requires a Python environment and <I>pip</I> for installation. While powerful, its web scraping capabilities can be affected by website changes, anti-bot measures, or rate limiting. Always respect <I>robots.txt</I> and website terms of service when scraping. Performance and accuracy can vary depending on the complexity and structure of the target webpage.


title: INPUT FROM STANDARD INPUT
content:
<i><b>trafilatura</b></i> can also process HTML content piped directly to it from standard input, making it highly flexible for integration into shell scripts. For example: <I>curl <URL> | <b>trafilatura</b></I>.


title: CONFIGURATION FILES
content:
<i>Advanced users can fine-tune extraction behavior using custom YAML configuration files, allowing for granular control over aspects like XPath expressions, content filtering, and metadata extraction rules.</i>


title: HISTORY
content:
<i><b>trafilatura</b></i> emerged as a project aiming to provide a robust, language-agnostic, and user-friendly solution for extracting boilerplate-free main content from web pages. Developed primarily in Python, it leverages techniques to intelligently identify and isolate relevant textual content, making it a reliable choice for diverse web scraping needs. Its development has focused on continuous improvement in accuracy and adaptability to the ever-evolving landscape of web design.


title: SEE ALSO
content:
curl(1): <i>Tool for transferring data from or to a server.</i>, wget(1): <i>Non-interactive network downloader.</i>, lynx(1): <i>A general purpose distributed information browser for the World Wide Web.</i>, pup(1): <i>A command-line HTML processor.</i>, python(1): <i>An interpreted, interactive, object-oriented programming language.</i>


title: TLDR
content:
<b>Extract text from a URL</b>`trafilatura [[-u|--URL]] [url]`<br><b>Extract text and save to a file</b>`trafilatura [[-u|--URL]] [url] [[-o|--output-dir]] [path/to/output.txt]`<br><b>Extract text in JSON format</b>`trafilatura [[-u|--URL]] [url] --json`<br><b>Extract text from multiple URLs listed in a file</b>`trafilatura [[-i|--input-file]] [path/to/url_list.txt]`<br><b>Crawl a website using its sitemap</b>`trafilatura --sitemap [url_to_sitemap.xml]`<br><b>Extract text while preserving HTML formatting</b>`trafilatura [[-u|--URL]] [url] --formatting`<br><b>Extract text including comments</b>`trafilatura [[-u|--URL]] [url] --with-comments`<br><b>Display help</b>`trafilatura [[-h|--help]]`


title: PARAMETERS
content:
<b>--prune</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Removes stale entries from the global status list. Stale entries are machines that are no longer running or tracked by Vagrant but still appear in the global list, usually due to unexpected shutdowns or manual file deletions. This ensures the list accurately reflects active environments.<br><br><b>--machine-id &lt;ID&gt;</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Filters the output to show only the machine with the specified unique ID. This ID is the one displayed in the first column of the <b>global-status</b> output.<br><br><b>--status &lt;STATUS&gt;</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Filters the output based on the machine's current state (e.g., 'running', 'saved', 'poweroff', 'not created'). This allows you to quickly find machines in a particular state.<br><br><b>--path &lt;PATH&gt;</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Filters the output to show only machines whose Vagrant project directory matches the given path.<br><br><b>--help</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Displays the help message for the <b>global-status</b> subcommand, listing available options and their usage.<br><br>


title: DESCRIPTION
content:
The <b>vagrant global-status</b> command provides a comprehensive overview of all active Vagrant environments across your entire system. Instead of navigating into each project directory to check its status, this command consolidates information from all tracked Vagrant machines.<br><br>For each active environment, it displays a unique <i>machine ID</i>, the machine's <i>name</i> (often derived from the Vagrantfile configuration), the <i>provider</i> (e.g., virtualbox, vmware_fusion), its current <i>state</i> (e.g., running, saved, poweroff), and the absolute <i>path</i> to the Vagrant project directory where the machine is defined.<br><br>This command is invaluable for developers working on multiple projects, allowing them to quickly identify which VMs are running, their states, and their locations. The displayed machine ID is particularly useful as it can be used with other Vagrant commands (like <b>vagrant ssh</b> or <b>vagrant destroy</b>) from any directory, providing a flexible way to interact with your VMs.


title: CAVEATS
content:
The <b>global-status</b> command only tracks Vagrant environments that have been started via <b>vagrant up</b> and haven't been fully destroyed. If Vagrant's internal state files become corrupted, the displayed list might be inaccurate or incomplete. The <b>--prune</b> option can take a significant amount of time to execute if there are many entries to check.


title: OUTPUT FORMAT
content:
The output of <b>vagrant global-status</b> is structured into several columns:<br><b>ID:</b> A unique identifier for the Vagrant machine.<br><b>Name:</b> The name of the machine, as defined in the Vagrantfile or automatically assigned.<br><b>Provider:</b> The virtualization provider being used (e.g., VirtualBox, VMware, Hyper-V).<br><b>State:</b> The current operational state of the machine (e.g., running, saved, poweroff, not created).<br><b>Path:</b> The absolute path to the Vagrant project directory where the machine is defined.


title: USING MACHINE IDS
content:
One of the most powerful features of <b>global-status</b> is the <i>machine ID</i>. This ID allows you to interact with a specific Vagrant machine from any directory on your system. For example, to SSH into a machine with ID <i>'abcdefg'</i>, you can simply run <b>vagrant ssh abcdefg</b>. Similarly, to destroy it, use <b>vagrant destroy abcdefg</b>. This eliminates the need to <b>cd</b> into the machine's project directory for common operations.


title: HISTORY
content:
The <b>global-status</b> command was introduced early in Vagrant's development by Mitchell Hashimoto to address a common need for managing multiple virtual machine environments. As Vagrant's adoption grew, so did the number of projects users managed, making a system-wide overview crucial. This command filled that gap, providing a centralized way to monitor and interact with all active Vagrant instances without the need to traverse directories.


title: TLDR
content:
<b>Display the state of all machines</b>`vagrant global-status`<br><b>Prune any stale entries from the output</b>`vagrant global-status --prune`


title: SYNOPSIS
content:
<i>vagrant port</i> [ <i>&lt;vm-name&gt;</i> ] [ <i>&lt;guest-port&gt;</i> ] [ <i>--guest &lt;GUEST_PORT&gt;</i> ] [ <i>--host &lt;HOST_PORT&gt;</i> ] [ <i>--protocol &lt;PROTOCOL&gt;</i> ] [ <i>--machine-readable</i> ]


title: PARAMETERS
content:
<b><i>&lt;vm-name&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;The name of the virtual machine to query. If omitted in a multi-VM setup, Vagrant will operate on the primary or default VM. For single-VM environments, it can often be omitted.<br><br><b><i>&lt;guest-port&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;A positional argument that specifies a particular guest port to find its corresponding host port. When used, the output will only show the mapping for this guest port.<br><br><b><i>--guest &lt;GUEST_PORT&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;An option to specify a particular guest port to find its corresponding host port. Similar to the positional <i>&lt;guest-port&gt;</i> argument but explicitly defined as an option.<br><br><b><i>--host &lt;HOST_PORT&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Filters the output to show mappings where the host port matches the specified value. Less commonly used for lookup, more for filtering.<br><br><b><i>--protocol &lt;PROTOCOL&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Filters the results by network protocol, such as <i>tcp</i> or <i>udp</i>, if the `Vagrantfile` explicitly defines protocols for port forwards.<br><br><b><i>--machine-readable</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Outputs the port forwarding information in a structured, machine-readable format, which is ideal for scripting and automation purposes.<br><br>


title: DESCRIPTION
content:
The `vagrant port` command is a crucial subcommand within the Vagrant ecosystem, a powerful tool designed for building and managing portable development environments. Its primary function is to <b>display the port forwarding configurations</b> for a specified Vagrant virtual machine. <br><br>When a `Vagrantfile` configures a forwarded port, it establishes a mapping between a port on the host machine and a port on the guest virtual machine. This mechanism allows services running inside the VM (e.g., a web server on port 80) to be accessed directly from the host machine's network (e.g., via <i>localhost:8080</i>). The `vagrant port` command enables developers to rapidly inspect these mappings without the need to manually parse the `Vagrantfile` or inspect provider-specific settings. <br><br>Users can either view all configured forwarded ports for a VM or query for a specific host port associated with a given guest port. This capability is invaluable for debugging network accessibility issues, confirming service exposure, or simply understanding how a development environment is configured. The output typically presents a clear list of guest ports, their corresponding host ports, and the protocol in use (e.g., TCP).


title: CAVEATS
content:
<i>vagrant port</i> requires <i>Vagrant</i> to be installed and a <i>Vagrant environment</i> (with an initialized <i>Vagrantfile</i>) to be present in the current directory or specified path.<br>It only displays ports that have been explicitly forwarded in the <i>Vagrantfile</i>. Other networking configurations (e.g., private or public networks) are not directly reported by this command.<br>In a multi-VM environment, omitting the <i>&lt;vm-name&gt;</i> argument may result in the command operating on an unintended VM. Always specify the VM name for clarity.<br>The accuracy of the reported port mappings relies on the correct configuration within the <i>Vagrantfile</i> and the underlying virtualization provider's ability to expose this information.


title: DEFAULT BEHAVIOR
content:
When executed without any arguments, <i>vagrant port</i> will typically list <b>all configured port forwardings</b> for the current Vagrant environment's primary or default virtual machine. This provides a quick overview of all accessible services.


title: MULTI-VM ENVIRONMENTS
content:
In environments configured with multiple virtual machines, it is essential to specify the target VM's name (e.g., <i>vagrant port webserver --guest 80</i>) to ensure the command queries the correct machine and displays relevant port mappings.


title: NO PORTS CONFIGURED
content:
If the <i>Vagrantfile</i> for a given environment does not define any forwarded ports, the <i>vagrant port</i> command will usually report no output or an empty list, indicating no explicit port mappings exist.


title: HISTORY
content:
The `vagrant port` subcommand emerged as a vital component of Vagrant's robust networking capabilities. As Vagrant evolved beyond basic single-VM setups to support complex multi-machine environments and diverse network configurations (including private, public, and forwarded ports), the necessity for an intuitive way to inspect these settings became increasingly apparent. The command provides a straightforward interface to quickly retrieve critical port mapping information, eliminating the need for users to manually parse configuration files or delve into provider-specific network settings. Its development has consistently mirrored the increasing sophistication and flexibility of Vagrant's networking features, ensuring that developers always have clear visibility into how their services are exposed and accessible.


title: TLDR
content:
<b>List all port mappings of machine(s) running in the current directory</b>`vagrant port`<br><b>List mappings for a specific machine (if Vagrantfile is multi-machine)</b>`vagrant port [machine_name]`<br><b>Display info for a specific guest port</b>`vagrant port --guest [port_number]`<br><b>Display machine-readable output</b>`vagrant port --machine-readable`


title: PARAMETERS
content:
<b><i>&lt;name&gt;</i> | <i>&lt;id&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Optional. Specifies the name or UUID of the virtual machine to resume. If omitted, Vagrant attempts to resume the primary VM in the current Vagrantfile directory.<br><br><b>--provision</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Optional. Forces Vagrant to run the configured provisioners after resuming the machine. By default, provisioning is not run during resume.<br><br><b>--debug</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Optional. Enables debug-level logging for detailed output, useful for troubleshooting issues with the resume process.<br><br>


title: DESCRIPTION
content:
The <b>vagrant resume</b> command reactivates a suspended Vagrant environment. When a Vagrant machine is suspended using <b>vagrant suspend</b>, its current state, including RAM and CPU state, is saved to disk. This allows for a quick restart without going through a full boot process. <br><br><b>vagrant resume</b> loads this saved state, bringing the virtual machine back to exactly where it left off. This is particularly useful for quickly pausing and unpausing development environments, saving host resources without losing work context. It's an efficient way to manage the lifecycle of a development VM, offering a faster alternative to performing a <b>vagrant halt</b> followed by a <b>vagrant up</b>, as it preserves the exact runtime state.


title: CAVEATS
content:
<i><b>Resuming may fail</b></i> if the underlying virtualization provider's configuration or host system environment has changed significantly since suspension.<br><i><b>Resource Consumption:</b></i> Can consume a significant amount of host RAM upon resume, equivalent to the VM's configured memory.<br><i><b>Provider Support:</b></i> Not all virtualization providers fully support the suspend/resume feature.<br><i><b>Pre-condition:</b></i> The command is only effective if the machine was previously suspended using <b>vagrant suspend</b>. If it was halted or powered off, <b>vagrant up</b> is required.


title: HOW IT WORKS
content:
When you execute <b>vagrant suspend</b>, the entire operational state of the virtual machine—including its RAM contents, CPU registers, and connected device states—is captured and written to a file on the host's disk. Subsequently, <b>vagrant resume</b> reads this saved state file back into memory, effectively restoring the VM to its exact previous operational state without the need for a full boot sequence, resulting in a much faster startup time.


title: RESOURCE USAGE CONSIDERATIONS
content:
While a virtual machine is suspended, it consumes no CPU cycles, which conserves host processing power. However, the saved state file created during suspension can occupy a significant amount of disk space, typically proportional to the VM's configured RAM. Upon resumption, this configured RAM is then re-allocated and consumed by the virtual machine on the host system.


title: HISTORY
content:
Vagrant, created by Mitchell Hashimoto, first saw its public release in 2010. The <b>suspend</b> and <b>resume</b> functionality has been a foundational element of Vagrant's lifecycle management capabilities since its early versions. This feature allows users to efficiently pause and unpause their development environments, leveraging the underlying virtualization provider's snapshot and suspend mechanisms. It quickly became an indispensable tool for optimizing resource management and facilitating rapid context switching in modern development workflows.


title: TLDR
content:
<b>Resume machine specified by name or id</b>`vagrant resume [name|id]`<br><b>Resume and run all configured provisioners</b>`vagrant resume [name|id] --provision`<br><b>Resume and specify which provisioners to re-run</b>`vagrant resume [name|id] --provision-with [provisioner]`


title: SYNOPSIS
content:
<b>vagrant ssh</b> [<i>options</i>] [<i>vm-name</i>] [<b>-c</b> <i>&lt;command&gt;</i>] [<b>--</b> <i>&lt;ssh-args&gt;</i>]


title: PARAMETERS
content:
<b>[<i>vm-name</i>]</b><br>&nbsp;&nbsp;&nbsp;&nbsp;The name of the specific virtual machine to connect to. Required if multiple VMs are defined in the Vagrantfile.<br><br><b><b>-c</b> <i>&lt;command&gt;</i>, <b>--command</b> <i>&lt;command&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Executes a single command on the remote virtual machine and then exits the SSH session. The command should be enclosed in quotes if it contains spaces.<br><br><b><b>--extra-args</b> <i>&lt;args&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Passes additional, raw arguments directly to the underlying <b>ssh</b> client. Arguments should typically be wrapped in quotes. This is an alternative to using <b>--</b>.<br><br><b><b>--plain</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Uses a 'plain' SSH connection without any Vagrant-specific configuration. This means Vagrant will not try to forward ports or setup authentication based on its internal knowledge.<br><br><b><b>--pty</b>, <b>--tty</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Forces pseudo-terminal allocation. This is useful when the remote command expects an interactive terminal, even if it's not a full shell.<br><br><b><b>--host-key-check</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Enables strict host key checking. By default, Vagrant often bypasses this for convenience in development environments. Use this for stricter security.<br><br><b><b>--debug</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Enables verbose debugging output for the SSH connection process, which can be useful for troubleshooting connectivity issues.<br><br><b><b>--</b> <i>&lt;ssh-args&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;A separator indicating that all subsequent arguments should be passed directly to the underlying <b>ssh</b> client. This is the recommended way to pass raw SSH arguments.<br><br>


title: DESCRIPTION
content:
The <b>vagrant ssh</b> command allows users to securely connect to a running Vagrant virtual machine (VM) via SSH. It simplifies the process by automatically handling SSH key management, port forwarding, and user configuration, abstracting away the complexities of direct SSH client usage. This command is essential for interacting with the guest operating system, enabling tasks such as installing software, configuring services, debugging applications, or simply exploring the VM's environment. It can be used to open an interactive shell session or to execute a single command remotely and then exit, providing flexibility for both manual interaction and automation workflows within your Vagrant development environment. If multiple VMs are defined in your Vagrantfile, you must specify which VM to connect to.


title: CAVEATS
content:
The <b>vagrant ssh</b> command requires the target virtual machine to be in a 'running' state. If the VM is halted, suspended, or not initialized, the command will fail. Ensure that an SSH server is running and accessible within the guest operating system. Network configurations (e.g., firewalls within the guest or on the host) can block SSH access. If using a multi-machine environment, failing to specify a <i>vm-name</i> will result in an error or a prompt to select a VM.


title: SSH CONFIGURATION MANAGEMENT
content:
Vagrant automatically generates and manages SSH key pairs for each VM, placing the private key in a secure location and configuring the guest OS with the corresponding public key. This removes the need for manual key generation and distribution, making the SSH connection seamless. It also configures SSH client settings like user and port automatically based on the Vagrantfile and provider information.


title: REMOTE COMMAND EXECUTION
content:
Beyond interactive shells, <b>vagrant ssh -c "&lt;command&gt;"</b> is incredibly useful for scripting and automation. It allows you to execute commands like '<b>vagrant ssh -c "sudo apt update"</b>' or '<b>vagrant ssh webserver -c "service apache2 restart"</b>' without needing to manually log in, making it a powerful tool for provisioning, testing, and deployment workflows.


title: TARGETING SPECIFIC VMS
content:
In a <i>multi-machine</i> Vagrantfile, where multiple virtual machines are defined (e.g., 'webserver', 'dbserver'), you must specify which VM you want to connect to: '<b>vagrant ssh webserver</b>'. If you omit the VM name and multiple VMs exist, Vagrant will either error or prompt you to choose, preventing ambiguous connections.


title: HISTORY
content:
The ability to SSH into a guest machine has been a fundamental feature of Vagrant since its inception by Mitchell Hashimoto. It addresses the core need for interacting with the development environment running within the VM. Over time, the <b>vagrant ssh</b> command has evolved to become more robust, handling various networking scenarios, multi-machine setups, and offering more options for passing raw SSH arguments, reflecting the growing complexity and versatility of Vagrant environments.


title: TLDR
content:
<b>SSH into the machine running in the current directory</b>`vagrant ssh`<br><b>Target a running machine by name or ID</b>`vagrant ssh [name|id]`<br><b>Execute an SSH command and exit</b>`vagrant ssh [[-c|--command]] [ssh_command]`<br><b>SSH without authentication, leaving authentication up to the user</b>`vagrant ssh [[-p|--plain]]`


title: SYNOPSIS
content:
<b>vagrant upload</b> [<i>options</i>] [<i>&lt;machine-name&gt;</i>] <i>&lt;src&gt;</i> <i>&lt;dest&gt;</i><br><br><i>&lt;machine-name&gt;</i>: The name of the guest machine to upload to. If omitted and only one machine is defined, it will be used.<br><i>&lt;src&gt;</i>: The path to the file or directory on the host machine to upload.<br><i>&lt;dest&gt;</i>: The destination path on the guest machine where the files will be placed.


title: PARAMETERS
content:
<b><b>-h</b>, <b>--help</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Prints a helpful usage message and exits.<br><br><b><b>-r</b>, <b>--recursive</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Uploads directories recursively, copying all their contents and subdirectories.<br><br><b><b>-u USER</b>, <b>--upload-as USER</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specifies the user on the guest machine under which the files should be uploaded.<br><br><b><b>-k</b>, <b>--keep-owners</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Attempts to preserve the original file owners and groups from the host on the guest machine. This often requires <i>sudo</i> privileges on the guest to execute <i>chown</i> commands.<br><br><b><b>--ssh-opts OPTS</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Passes additional SSH options directly to the underlying <i>scp</i> command. For example, <i>-P 2222</i> for specific port forwarding.<br><br><b><b>--host HOST</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;If a single Vagrant machine definition has multiple guests (e.g., using a multi-machine setup), this option allows specifying which host to connect to for the upload.<br><br><b><b>--port PORT</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Similar to <b>--host</b>, this specifies the port for connecting to a particular guest in a multi-guest machine configuration.<br><br>


title: DESCRIPTION
content:
The <b>vagrant upload</b> command provides a convenient way to transfer files or directories from your host machine to a running Vagrant guest machine. It abstracts away the complexities of manual <i>scp</i> commands by automatically determining the guest's connection details (IP address, SSH port, username, private key). This command is particularly useful for quickly deploying configuration files, scripts, or application code to your development environment without needing to SSH into the VM first.<br><br>It supports recursive uploads for directories and offers options for specifying target users and preserving file ownership, making it an essential tool for streamlining file synchronization within your Vagrant-managed environments.


title: CAVEATS
content:
<ul><li>The guest machine must be running and accessible via SSH for <b>vagrant upload</b> to function.</li><li>Permissions on the guest machine might prevent uploads to certain directories unless the <b>--upload-as</b> option is used with a privileged user or the target directory is writable by the default vagrant user.</li><li>The <b>--keep-owners</b> option typically requires <i>sudo</i> privileges on the guest machine for the Vagrant user to successfully execute <i>chown</i> and <i>chgrp</i> commands.</li><li>This command is specifically for uploading files from the host to the guest. For downloading files from the guest, you would need to use <b>vagrant scp</b> or the direct <b>scp</b> command.</li><li>Large file transfers can be slow depending on network conditions and VM performance.</li></ul>


title: UNDERLYING MECHANISM
content:
Under the hood, <b>vagrant upload</b> leverages the Secure Copy Protocol (SCP) over SSH. It automatically uses the SSH connection details configured by Vagrant for the specified guest machine, including the private key and forwarded port, eliminating the need for manual configuration and making file transfers seamless within the Vagrant ecosystem.


title: HISTORY
content:
The <b>vagrant upload</b> command was introduced in Vagrant to simplify the common task of transferring files to a guest VM. Prior to its introduction, users often had to manually construct complex <i>scp</i> commands, which required looking up the VM's dynamic SSH port, IP address, and private key path. This command streamlined the development workflow by providing a more user-friendly and automated interface for host-to-guest file synchronization, directly integrating with Vagrant's machine management capabilities.


title: TLDR
content:
<b>Upload file or directory from the host to the guest machine</b>`vagrant upload [path/to/source_file_or_directory] [path/to/destination_file_or_directory] [name|id]`<br><b>Compress the file or directory before uploading to guest machine</b>`vagrant upload --compress [path/to/source_file_or_directory] [path/to/destination_file_or_directory] [name|id]`<br><b>Specify which type of compression to use. Default type is zip</b>`vagrant upload --compression-type [tgz|zip] [path/to/source_file_or_directory] [path/to/destination_file_or_directory] [name|id]`<br><b>Create a temporary location on the guest machine and upload files to that location</b>`vagrant upload --temporary [path/to/source_file_or_directory] [path/to/destination_file_or_directory] [name|id]`


title: PARAMETERS
content:
<b><b>--machine-readable</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Outputs the version information in a structured, machine-readable format. This is particularly useful for scripting and automation where parsing human-readable output would be cumbersome.<br><br><b><b>--help</b>, <b>-h</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Displays a help message for the <I>version</I> subcommand, detailing its usage and available options.<br><br>


title: DESCRIPTION
content:
The <B>vagrant version</B> command is a fundamental subcommand of the <I>Vagrant</I> command-line interface (CLI) tool. Its primary purpose is to display the currently installed version of Vagrant on the system. Beyond just the main Vagrant application version, it typically provides a comprehensive overview that includes the versions of any installed Vagrant plugins. In some cases, it might also offer insights into the version of the underlying virtualization provider (such as VirtualBox or VMware) that Vagrant is configured to use.<br><br>This command is invaluable for various reasons: it aids in debugging compatibility issues between different Vagrant versions, ensures that a user is running the desired or required version for a specific Vagrantfile, and serves as a quick diagnostic tool to verify the health and status of the Vagrant installation. It does not alter any system configuration or state; instead, it provides crucial diagnostic information for system administrators and developers working with Vagrant environments.


title: CAVEATS
content:
The command you specified, <B>vagrant-version</B>, is not a standard Linux command or a direct Vagrant subcommand. The correct command to check the Vagrant version is <B>vagrant version</B> (note the space). If <I>Vagrant</I> is not installed on your system or not present in your shell's PATH environment variable, executing <B>vagrant version</B> will result in a 'command not found' error. Always ensure Vagrant is properly installed and accessible.


title: TYPICAL OUTPUT
content:
When run without options, <B>vagrant version</B> typically displays the Vagrant version, the installed provider (e.g., VirtualBox), and a list of installed plugins with their respective versions. For example:<br><br><I>Installed Version: 2.3.4<br>Latest Version: 2.3.7<br><br>VirtualBox Provider: 6.1.4<br><br>Installed Plugins:<br>  vagrant-share (1.1.9)</I>


title: USAGE CONTEXT
content:
This command is frequently used when troubleshooting issues, verifying a new installation, or confirming that the environment meets specific version requirements for a Vagrant project. It helps developers and operations teams maintain consistency across their development and testing environments.


title: HISTORY
content:
Vagrant, developed by Mitchell Hashimoto, has incorporated the <B>version</B> subcommand as a core utility since its early releases. Its inclusion was essential for users to quickly verify their Vagrant installation, especially as the tool gained popularity and new versions with differing functionalities emerged. Over time, the output of the <B>vagrant version</B> command evolved to include more details, such as installed plugin versions, reflecting the modular nature and extensibility of Vagrant's architecture. This continuous refinement has made it an even more powerful diagnostic tool for the Vagrant community.


title: TLDR
content:
<b>Display the currently installed version and latest version of Vagrant that is currently available</b>`vagrant version`<br><b>Display version</b>`vagrant --version`


title: SYNOPSIS
content:
<b>dutree</b> [<i>options</i>] [<i>directory...</i>]<br><br><i>Example:</i> <b>dutree -h -L 2 /var/log</b>


title: PARAMETERS
content:
<b><b>-h</b>, <b>--human-readable</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Display sizes in human-readable format (e.g., 1K, 234M, 2G).<br><br><b><b>-L</b> <i>&lt;level&gt;</i>, <b>--level</b> <i>&lt;level&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Descend only <i>&lt;level&gt;</i> directories deep. A value of 1 shows only direct children.<br><br><b><b>-d</b>, <b>--directories-only</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;List directories only, omitting individual files from the output tree.<br><br><b><b>-a</b>, <b>--all</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Include hidden files and directories (those starting with a dot) in the output.<br><br><b><b>-x</b>, <b>--one-file-system</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Skip directories that are on different file systems than the starting directory.<br><br><b><b>-I</b> <i>&lt;pattern&gt;</i>, <b>--exclude</b> <i>&lt;pattern&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Exclude files or directories whose names match the specified <i>&lt;pattern&gt;</i>.<br><br><b><b>--total</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Display a grand total disk usage at the end of the output.<br><br>


title: DESCRIPTION
content:
`<b>dutree</b>` is a powerful, though <i>not standard</i>, command-line utility designed to provide a comprehensive, tree-like visualization of disk space usage. It effectively combines the functionality of `<b>du</b>` (disk usage) and `<b>tree</b>` (list directory contents in a tree-like format) into a single, easy-to-read output. This utility is typically implemented as a shell script by the community to address the common need for a quick, visual overview of how disk space is distributed across directories and files. Unlike `<b>du</b>` which lists sizes line by line, or `<b>tree</b>` which only shows structure, `<b>dutree</b>` presents directory sizes directly within a hierarchical structure, making it exceptionally useful for identifying disk space hogs and managing storage efficiently. Its non-standard nature means implementations can vary, but the core objective remains consistent: to provide an intuitive, navigable insight into your file system's storage consumption.


title: CAVEATS
content:
Unlike standard Linux commands, `<b>dutree</b>` is typically a community-developed script or utility, meaning its exact behavior, available options, and even its existence can vary significantly between systems. <br>Users should be aware that it often relies on the underlying `<b>du</b>` and `<b>tree</b>` commands being installed and accessible in the system's PATH. <br>When dealing with extremely large or deeply nested file systems, `<b>dutree</b>` can be resource-intensive and may take considerable time to execute. <br>Furthermore, as it's often sourced from various community repositories, users should exercise caution and verify the script's content before execution to prevent potential security risks.


title: INSTALLATION AND AVAILABILITY
content:
As `<b>dutree</b>` is not part of standard Linux distributions, users typically install it by downloading a script from a community repository (e.g., GitHub) or by creating their own script. The downloaded script usually needs to be made executable (`<b>chmod +x dutree</b>`) and placed in a directory included in the system's PATH (e.g., `<b>/usr/local/bin</b>` or `<b>~/bin</b>`). It is highly recommended to review the script's content before execution to ensure its safety and intended functionality.


title: TYPICAL USAGE
content:
`<b>dutree</b>` is primarily used for disk space analysis and cleanup. Users frequently employ it to: <br>1. Quickly identify which directories are consuming the most disk space.<br>2. Visualize the size distribution within a specific project directory.<br>3. Audit file system usage after large data operations.<br>4. Find large, unnecessary files or directories that can be archived or deleted.<br>The various options allow for granular control, such as limiting the depth of the tree (`<b>-L</b>`), showing human-readable sizes (`<b>-h</b>`), or excluding specific file types (`<b>-I</b>`).


title: HISTORY
content:
The history of `<b>dutree</b>` is not one of a single, formally developed project, but rather an organic emergence from the practical needs of Linux users. Faced with the separate functionalities of `<b>du</b>` (for disk usage reporting) and `<b>tree</b>` (for hierarchical directory listing), users often sought a unified tool to visualize disk space directly within a directory structure. This led to numerous independent shell script implementations shared across personal dotfiles, online forums, and platforms like GitHub. These scripts typically combined piping the output of `<b>du</b>` into a processing logic that reformatted it into a `<b>tree</b>`-like display. Consequently, `<b>dutree</b>` represents a common solution pattern rather than a canonical command, continuously evolving through community contributions based on diverse user requirements and preferences.


title: PARAMETERS
content:
<b><i><code>-D&lt;property&gt;=&lt;value&gt;</code></i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Sets a system property, commonly used to pass configuration parameters to plugins bound to the <i><code>generate-sources</code></i> phase, such as schema locations or generation options.<br><br><b><i><code>-P &lt;profile_id&gt;</code></i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Activates a specified build profile. Profiles can contain specific plugin configurations for code generation, allowing different sets of sources to be generated based on the environment or build target.<br><br><b><i><code>-f &lt;file&gt;</code></i>, <i><code>--file &lt;file&gt;</code></i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specifies an alternative path to the <i><code>pom.xml</code></i> file. Useful when the project's build file is not in the default location.<br><br><b><i><code>-B</code></i>, <i><code>--batch-mode</code></i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Runs in non-interactive (batch) mode. Useful for automated scripts or continuous integration environments where user input is not possible.<br><br><b><i><code>-U</code></i>, <i><code>--update-snapshots</code></i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Forces a check for updated releases and snapshots from remote repositories. Ensures the latest versions of plugins or dependencies required for code generation are used.<br><br><b><i><code>-X</code></i>, <i><code>--debug</code></i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Produces execution debug output. Invaluable for troubleshooting issues related to plugin configuration or execution during the <i><code>generate-sources</code></i> phase.<br><br><b><i><code>-q</code></i>, <i><code>--quiet</code></i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Works quietly, showing minimal output. Useful for clean logs in automated builds when only errors are of interest.<br><br><b><i><code>-o</code></i>, <i><code>--offline</code></i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Works offline, preventing <b>Maven</b> from connecting to remote repositories. Requires all necessary plugins and dependencies to be present in the local repository.<br><br>


title: DESCRIPTION
content:
The command <i><code>mvn generate-sources</code></i> executes the <i><code>generate-sources</code></i> phase of the <b>Maven</b> build lifecycle. This phase is strategically positioned to create or prepare any necessary source files that will be consumed by subsequent phases, particularly the <i><code>compile</code></i> phase.<br><br>It's crucial for projects that rely on code generation. Common scenarios include:<br><i><b><br></b></i><ul><li><i><b>Schema compilation:</b></i> Generating Java classes from XML schemas (e.g., JAXB) or Protocol Buffers definitions.</li><li><i><b>Grammar compilation:</b></i> Generating parsers and lexers from grammar definitions (e.g., ANTLR).</li><li><i><b>API contract generation:</b></i> Creating client or server stubs from OpenAPI/Swagger specifications.</li><li><i><b>Annotation processing:</b></i> Tools like Lombok or MapStruct often perform their code generation around this phase, though sometimes it's associated with <i><code>process-sources</code></i> or <i><code>compile</code></i>.</li></ul>The <i><code>generate-sources</code></i> phase itself doesn't perform any direct action; it acts as a hook where <b>Maven</b> plugins are configured to execute their goals. These plugins add the newly generated source directories to the project's build path, ensuring that the <i><code>compile</code></i> phase can locate and compile them alongside the handwritten sources. Executing this command explicitly ensures that all code generation tasks are completed before any compilation attempts.


title: CAVEATS
content:
The <i><code>generate-sources</code></i> phase only performs actions if plugins are explicitly configured in the <i><code>pom.xml</code></i> to execute goals during this phase. Without such configurations, running <i><code>mvn generate-sources</code></i> will simply execute all preceding lifecycle phases without any visible source generation.<br><br>Care must be taken to ensure that generated sources are correctly added to the project's source directories (e.g., using <i><code>build-helper-maven-plugin:add-source</code></i>) so that the <i><code>compile</code></i> phase can find them. Misconfigurations can lead to compilation errors or missing classes.


title: <B>MAVEN BUILD LIFECYCLE</B>
content:
The <i><code>generate-sources</code></i> phase is part of <b>Maven's</b> standard build lifecycle, which defines a sequence of phases to build a project. It typically occurs after <i><code>process-resources</code></i> and before <i><code>process-sources</code></i> and <i><code>compile</code></i>. This ordering ensures that all resources are processed, then any necessary sources are generated, before the primary source code is compiled.


title: <B>CONFIGURING PLUGINS</B>
content:
The actual work of generating sources is performed by specific <b>Maven</b> plugins configured in the <i><code>&lt;build&gt;</code></i> section of the <i><code>pom.xml</code></i>. Examples include:<br><i><b><br></b></i><ul><li><i><code>jaxb-maven-plugin</code></i> (for XML to Java generation)</li><li><i><code>protobuf-maven-plugin</code></i> (for Protocol Buffers)</li><li><i><code>antlr4-maven-plugin</code></i> (for ANTLR grammars)</li><li><i><code>build-helper-maven-plugin</code></i> (specifically its <i><code>add-source</code></i> goal, crucial for including generated directories into the classpath)</li></ul>These plugins bind their goals to the <i><code>generate-sources</code></i> phase, instructing <b>Maven</b> to execute them at the appropriate time.


title: HISTORY
content:
The concept of a defined build lifecycle, including the <i><code>generate-sources</code></i> phase, has been a cornerstone of <b>Maven</b> since its early versions (Maven 2.x onwards, formalizing practices from Maven 1.x). Its inclusion reflects the growing complexity of software projects and the increasing reliance on automated code generation from various descriptions (e.g., schemas, grammars, models). The stability and predictable ordering of phases like <i><code>generate-sources</code></i> ensure that generated code is consistently produced and integrated into the build process at the correct time, predating the actual compilation.


title: SEE ALSO
content:
<i><code>mvn compile</code></i>, <i><code>mvn package</code></i>, <i><code>mvn install</code></i>, <i><code>mvn clean</code></i>, <i><code>maven(1)</code></i>


title: SYNOPSIS
content:
<pre>npm hook add &lt;pkg&gt; &lt;url&gt; &lt;secret&gt; [--type=&lt;type&gt;]<br>npm hook ls [&lt;pkg&gt;]<br>npm hook update &lt;id&gt; &lt;url&gt; &lt;secret&gt;<br>npm hook rm &lt;id&gt;</pre><i>Note: &lt;pkg&gt; refers to the package name, &lt;url&gt; is the webhook target, &lt;secret&gt; is a shared secret string for verification, &lt;type&gt; refers to the event type (default: package), and &lt;id&gt; is the unique ID of an existing hook.</i>


title: PARAMETERS
content:
<b>pkg</b><br>&nbsp;&nbsp;&nbsp;&nbsp;The <i>name</i> of the npm package for which to manage hooks. Used with <code>add</code> and <code>ls</code>.<br><br><b>url</b><br>&nbsp;&nbsp;&nbsp;&nbsp;The <i>target URL</i> where the webhook payload will be sent. Used with <code>add</code> and <code>update</code>.<br><br><b>secret</b><br>&nbsp;&nbsp;&nbsp;&nbsp;A <i>secret string</i> used to sign the webhook payload, enabling the receiver to verify the authenticity of the request. Used with <code>add</code> and <code>update</code>.<br><br><b>--type=<type></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specifies the <i>type</i> of event the hook should respond to. Currently, `package` is the primary supported type, covering <code>publish</code>, <code>unpublish</code>, and <code>dist-tag</code> changes. Used with <code>add</code>.<br><br><b>id</b><br>&nbsp;&nbsp;&nbsp;&nbsp;The <i>unique identifier</i> of an existing hook, obtained from <code>npm hook ls</code>. Used with <code>update</code> and <code>rm</code>.<br><br><b>--json</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Output data in <i>JSON format</i>. Applies to <code>ls</code>.<br><br><b>--registry=<url></b><br>&nbsp;&nbsp;&nbsp;&nbsp;The <i>registry URL</i> to use for the command, overriding the default.<br><br><b>--loglevel=<level></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Set the <i>logging level</i> for output messages.<br><br>


title: DESCRIPTION
content:
The `npm hook` command provides a mechanism for package maintainers to manage webhooks associated with their packages on the npm registry. These webhooks allow external services to be notified and react automatically when specific events occur related to a package, such as <b>publish</b>, <b>unpublish</b>, or <b>dist-tag</b> changes. By setting up webhooks, developers can integrate their npm package workflow with various external tools for purposes like continuous integration, deploying documentation, sending notifications, or updating other systems.<br><br>The command offers subcommands to <b>add</b> new hooks, <b>ls</b> (list) existing hooks for a package or globally, <b>update</b> an existing hook's details (like its URL or secret), and <b>rm</b> (remove) a hook. Each hook requires a target URL to send the payload to and a secret for signature verification, ensuring the authenticity of the incoming webhook requests. This feature is crucial for automating tasks and building responsive systems around package lifecycle events in the npm ecosystem.


title: CAVEATS
content:
<b>Authentication Required:</b> Users must be logged in to npm (<code>npm login</code>) and have appropriate permissions (ownership or maintainer status) for the target package to manage its hooks.<br><b>Security of Secrets:</b> The <i>secret</i> provided for webhooks should be a strong, randomly generated string. It's crucial for verifying the authenticity of incoming webhook requests and should be stored securely.<br><b>Registry Specific:</b> Hooks are managed specifically for the npm registry and are not generic system hooks.<br><b>Limited Scope:</b> Currently, the primary event type supported is `package`, covering publish, unpublish, and dist-tag changes. Other event types might be limited or not directly exposed via the `add` command's <code>--type</code> option.<br><b>Rate Limits:</b> While not strictly documented for `npm hook` itself, webhooks usually have associated rate limits or delivery guarantees set by the registry.


title: WEBHOOK PAYLOAD STRUCTURE
content:
When a webhook is triggered, the npm registry sends an HTTP POST request to the configured <i>URL</i>. The request body contains a JSON payload with details about the event (e.g., package name, version, event type). The request also includes an `x-npm-signature` header, which is a HMAC-SHA256 signature calculated using the <i>secret</i> and the payload, allowing the receiver to verify the request's origin.


title: VERIFICATION AND TESTING
content:
After adding a hook, it's recommended to test it by performing the triggering action (e.g., publishing a test package) or by sending a dummy payload to the webhook <i>URL</i> and checking the recipient service for logs. Services like `webhook.site` can be used to quickly inspect incoming webhook payloads.


title: HISTORY
content:
The `npm hook` subcommand was introduced with <i>npm version 5.7.0</i>, released in early 2018. Its introduction marked a significant step towards enabling greater automation and integration capabilities for package maintainers within the npm ecosystem. Prior to this, programmatic reactions to package events typically required polling the npm registry or relying on external services that provided such functionality. The `hook` command provided a native, first-party solution for setting up real-time notifications, aligning npm with modern software development practices that emphasize continuous integration and automated workflows. It aimed to empower maintainers to build more sophisticated and responsive tooling around their package releases.


title: SYNOPSIS
content:
<I>npm publish</I> [<B>&lt;folder&gt;</B>|<B>&lt;tarball&gt;</B>] [--<B>tag</B> <B>&lt;tag&gt;</B>] [--<B>access</B> <B>&lt;public|restricted&gt;</B>] [--<B>otp</B> <B>&lt;otpcode&gt;</B>] [--<B>dry-run</B>] [--<B>registry</B> <B>&lt;url&gt;</B>] [--<B>workspace</B> <B>&lt;workspace_name&gt;</B>] [--<B>workspaces</B>]


title: PARAMETERS
content:
<b>--tag <tag></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Registers the published package with the given tag. This can be used to provide an alias for the package version, such as `beta` or `next`, instead of the default `latest`.<br><br><b>--access <public|restricted></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Controls the visibility of scoped packages. Scoped packages default to `restricted` (private) access, requiring this option to be `public` for free open-source publishing. Unscoped packages are always `public`.<br><br><b>--otp <otpcode></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Provides a one-time password for two-factor authentication, if required by the npm registry.<br><br><b>--registry <url></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specifies a custom registry URL to publish the package to, overriding the default configured registry.<br><br><b>--dry-run</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Performs all publishing steps except the actual upload to the registry. Useful for previewing what files will be included and what scripts will run without making permanent changes.<br><br><b>--workspace <workspace_name></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Publishes a package from a specific workspace within a monorepo setup.<br><br><b>--workspaces</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Publishes all packages from all defined workspaces in the current project.<br><br><b>--if-present</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Used with `--workspaces`, it will only run `publish` for workspaces that are present in the `workspaces` array.<br><br><b>--provenance</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Adds provenance information to the package metadata, linking the build and publishing process to its source.<br><br><b>--no-git-checks</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Bypasses the checks that ensure your package repository is clean and on the main branch before publishing. Use with caution.<br><br><b>--ignore-scripts</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Prevents the execution of `prepublish`, `prepare`, `prepublishOnly`, and `postpublish` lifecycle scripts during the publish process.<br><br>


title: DESCRIPTION
content:
The `npm publish` command uploads a package to the npm registry, making it available for others to install. It works by taking the current directory (or a specified folder/tarball) and packaging its contents according to the `package.json` specification. Before publishing, `npm publish` performs several checks, including validating the `package.json`, ensuring the package name and version are unique (or scoped), and respecting `.npmignore` and `.gitignore` files to exclude unnecessary files. It compresses the package into a tarball and then uploads it to the configured npm registry. This command is fundamental for sharing reusable JavaScript modules and applications within the Node.js ecosystem. It supports various options to control access, associate tags (like `latest` or `beta`), specify a different registry, and manage two-factor authentication requirements. It's crucial to ensure your `package.json` correctly defines your package's metadata and files to be included.


title: CAVEATS
content:
<b>Authentication Required:</b> You must be logged in to npm (`npm login`) with credentials that have publishing rights to the package or scope.<br><b>Version Uniqueness:</b> Each version of a package must be unique on the registry. Attempting to publish an existing version will result in an error.<br><b>Scoped Package Access:</b> Scoped packages (`@scope/package-name`) default to `restricted` access. To publish them publicly, you must explicitly use `--access public`.<br><b>Immutable After 72 Hours:</b> Published packages are generally considered immutable. Unpublishing is highly discouraged and only possible within 72 hours of publication, and only if no other packages depend on it.<br><b>Sensitive Information:</b> Ensure no sensitive information (e.g., API keys, private configuration) is included in your package. Use `.npmignore` or the `files` array in `package.json` to control what gets published.<br><b>Git State:</b> By default, `npm publish` will warn or error if your working directory is not clean or if you are not on the main branch. This can be overridden with `--no-git-checks`, but is not recommended.


title: <B>CONTROLLING PUBLISHED FILES</B>
content:
The files included in your published package are determined by the `files` array in your `package.json` and `.npmignore` (or `.gitignore`).<br>The `files` array explicitly lists files or directories to include. If `files` is not specified, `npm publish` will include all files not ignored by `.npmignore` or `.gitignore`. A `.npmignore` file works similarly to `.gitignore` but is specific to npm, taking precedence over `.gitignore` for published content. It's crucial to properly configure these to avoid publishing sensitive data or unnecessary large files.


title: <B>PUBLISHING LIFECYCLE SCRIPTS</B>
content:
`npm publish` triggers several lifecycle scripts defined in `package.json`. These include:<br>• <B><I>prepublish:</I></B> (deprecated, superseded by `prepare` and `prepublishOnly`) Runs before the package is packed and published.<br>• <B><I>prepare:</I></B> Runs before the package is packed, regardless of whether it's for `publish`, `install`, or `pack`. Ideal for transpilation or build steps.<br>• <B><I>prepublishOnly:</I></B> Runs <I>only</I> before `npm publish`. Good for final checks or builds specifically for publishing.<br>• <B><I>postpublish:</I></B> Runs after the package has been successfully published. Useful for cleanup or notification.<br>Understanding these scripts is vital for managing your package's build and deployment process correctly.


title: <B>DEFAULT TAGS AND ALIASES</B>
content:
By default, `npm publish` sets the `--tag` to `latest`. This means `npm install <package-name>` will install the version published with the `latest` tag. You can publish a new version with a different tag (e.g., `npm publish --tag beta`) and later promote it to `latest` using `npm dist-tag add <package-name>@<version> latest`. This allows for managing different release channels (e.g., stable, beta, alpha) for your package.


title: HISTORY
content:
The `npm publish` command has been a core component of the Node Package Manager since its early days, facilitating the sharing and reuse of JavaScript modules. Its functionality has evolved significantly to accommodate the growing npm ecosystem. Key developments include the introduction of <B>scoped packages</B> in npm version 2, allowing for namespaced packages (e.g., `@scope/package`), and the subsequent addition of the `--access` option to manage their public/restricted visibility. Support for <B>two-factor authentication</B> (`--otp`) was integrated to enhance security for publishers. More recently, features like <B>workspaces</B> (introduced in npm 7) streamlined the publishing of multiple interdependent packages from monorepos, and the `--provenance` flag was added to provide verifiable supply chain information, reflecting ongoing efforts to improve security and transparency in package distribution.


title: SEE ALSO
content:
<I>npm login</I>(1), <I>npm logout</I>(1), <I>npm install</I>(1), <I>npm pack</I>(1), <I>npm version</I>(1), <I>npm owner</I>(1), <I>npm unpublish</I>(1), <I>npm view</I>(1), <I>npm config</I>(1), <I>npm access</I>(1)


title: SYNOPSIS
content:
<pre><b>npm-rb</b> [<i>&lt;npm_command&gt;</i>] [<i>&lt;npm_options&gt;</i>] [<i>&lt;arguments&gt;</i>]</pre><br><I>Examples:</I><br><pre><b>npm-rb</b> install<br><b>npm-rb</b> run build<br><b>npm-rb</b> --version</pre><I>Note: This synopsis assumes `npm-rb` acts as a direct passthrough to the underlying `npm` executable.</I>


title: PARAMETERS
content:
<b><i>&lt;npm_command&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Any valid <b>npm</b> command (e.g., <b>install</b>, <b>update</b>, <b>run</b>, <b>test</b>, <b>start</b>).<br><br><b><i>&lt;npm_options&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Any valid options supported by the <b>npm</b> command being executed (e.g., <b>--save-dev</b>, <b>--global</b>, <b>--prefix</b>).<br><br><b><i>&lt;arguments&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Additional arguments passed directly to the <b>npm</b> command or its sub-processes.<br><br>


title: DESCRIPTION
content:
<b>npm-rb</b> is a hypothetical or custom command-line utility designed to provide a seamless interface for Ruby projects to interact with the Node Package Manager (<b>npm</b>). While not a standard Linux command or a widely distributed standalone tool, it typically manifests as a shell script or a Ruby gem wrapper that streamlines the execution of <b>npm</b> commands within a Ruby-centric development environment.<br><br>The primary goal of such a utility would be to simplify workflows where Ruby applications (e.g., Rails applications using Webpack or other JavaScript tooling) need to manage Node.js dependencies. It might simply proxy arguments directly to the underlying <b>npm</b> executable, or it could add Ruby-specific logic for configuration management, environment setup, or integration with Ruby build systems. Its existence often points to a desire to unify dependency management or automate tasks across polyglot project stacks.


title: CAVEATS
content:
<b>npm-rb</b> is not a standard Linux command and is generally not available out-of-the-box. Its functionality, existence, and specific syntax are entirely dependent on whether it has been custom-implemented in a particular development environment, project, or by a specific Ruby gem. Users attempting to execute <b>npm-rb</b> without a pre-existing definition will likely encounter a "command not found" error. If it exists, it is typically a thin wrapper script, so its behavior is closely tied to the <b>npm</b> version and configuration available on the system.


title: PURPOSE AND IMPLEMENTATION
content:
The main purpose of <b>npm-rb</b> is to create a more integrated and consistent developer experience for projects that use both Ruby and Node.js. It's often implemented as a simple shell script (`#!/bin/sh`) or a Ruby script (`#!/usr/bin/env ruby`) that takes command-line arguments and passes them through to the <b>npm</b> executable. Some advanced implementations might add logic for detecting project environments, managing `package.json` files, or integrating with Ruby task runners like Rake.


title: CUSTOM ALIASES VS. SCRIPTS
content:
It's important to distinguish between a custom shell alias (e.g., `alias npm-rb='npm'`) and a more elaborate script. While an alias merely renames the <b>npm</b> command, a script named <b>npm-rb</b> would offer the flexibility to inject custom logic, environment variables, or default behaviors before or after invoking <b>npm</b>.


title: HISTORY
content:
The concept behind <b>npm-rb</b> likely emerged from the increasing prevalence of polyglot development stacks, particularly Ruby-on-Rails applications integrating heavily with JavaScript front-end tooling (like Webpack, Babel, etc.) managed by <b>npm</b>. Developers often sought ways to unify or simplify the management of both Ruby (via Bundler/Gems) and JavaScript (via <b>npm</b>) dependencies.<br><br>Rather than a formal project, <b>npm-rb</b> typically represents a class of custom scripts or internal tools created by teams to provide a consistent interface or automate specific tasks, bridging the two distinct package management ecosystems within a single workflow.


title: PARAMETERS
content:
<b>[&lt;@scope&gt;]/&lt;pkg&gt;...</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Optional. One or more package names to rebuild. If no package names are provided, all packages in the <i>node_modules</i> tree will be rebuilt.<br><br><b>--prefix &lt;path&gt;</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Operate on the package in the given path rather than the current working directory. This allows rebuilding dependencies of a project located elsewhere.<br><br><b>--production</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Rebuild only <i>dependencies</i> and not <i>devDependencies</i>. This is useful for production environments to minimize build time and footprint.<br><br><b>--dry-run</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Run the command without actually performing any actions. This shows what would happen, which can be useful for debugging or previewing changes.<br><br><b>--unsafe-perm</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Set to true to run scripts as root. It is often necessary for native module compilation, especially when installing global packages or when compilers require elevated permissions.<br><br>


title: DESCRIPTION
content:
The <i>npm rebuild</i> command is used to recompile and rebuild native Node.js add-ons for one or more packages, or for all packages in the <i>node_modules</i> directory. Native add-ons are modules written in languages like C or C++ that are compiled against a specific Node.js version and system architecture.<br><br>This command is essential when the Node.js version changes, when a project's <i>node_modules</i> directory is moved between different operating systems or architectures, or when a native dependency fails to build correctly during an <i>npm install</i>. It effectively traverses the dependency tree, identifies packages with native components (typically indicated by a <i>binding.gyp</i> file), and attempts to recompile them using <i>node-gyp</i>. This ensures that the native modules are compatible with the current environment, resolving potential runtime errors due to ABI mismatches.


title: CAVEATS
content:
<b>Build Tools Required:</b> Rebuilding native add-ons requires a proper development environment, including C/C++ compilers (e.g., GCC, Clang, MSVC), Python (usually 2.x or 3.x), and <i>make</i> (on Unix-like systems). On Debian/Ubuntu, this often means installing the <i>build-essential</i> package; on macOS, Xcode Command Line Tools; and on Windows, Visual Studio.<br><br><b>Time Consuming:</b> Depending on the number and complexity of native modules, the rebuild process can take a significant amount of time and consume considerable CPU resources.<br><br><b>Permission Issues:</b> Native module compilation can sometimes encounter permission errors, especially if global packages are being rebuilt or if the build process attempts to write to restricted directories. Using <i>--unsafe-perm</i> or running with <i>sudo</i> might be necessary (use with caution).<br><br><b>Compilation Errors:</b> Even with correct tools, compilation can fail due to specific module requirements, incompatible compiler versions, or missing system libraries. Reviewing the detailed error output is crucial for troubleshooting.


title: UNDERLYING MECHANISM: NODE-GYP
content:
<i>npm rebuild</i> internally leverages <i>node-gyp</i>, a cross-platform command-line tool written in Node.js, to compile the native add-on modules. <i>node-gyp</i> reads a <i>binding.gyp</i> file (a project configuration file) within each native package to determine how to build the module, fetch Node.js headers, and invoke the system's C/C++ compiler. Understanding <i>node-gyp</i> can be beneficial for advanced troubleshooting of compilation issues.


title: WHEN TO USE NPM REBUILD
content:
You should consider using <i>npm rebuild</i> in situations such as:<br><i>1.</i> After upgrading or downgrading your Node.js version.<br><i>2.</i> When transferring a <i>node_modules</i> directory from one machine to another with a different operating system or CPU architecture.<br><i>3.</i> If you encounter errors like 'Module did not self-register' or 'The specified module could not be found' for native modules after an <i>npm install</i>.<br><i>4.</i> When development environments (e.g., compilers) on your system change significantly.


title: HISTORY
content:
<i>npm rebuild</i> has been a fundamental utility within the npm ecosystem since its early days, addressing the persistent challenge of managing native Node.js add-ons. Its development paralleled the growth of Node.js and the increasing adoption of native modules for performance-critical tasks or system-level interactions. The command's core functionality, which relies heavily on <i>node-gyp</i>, has remained consistent: to provide a reliable way for developers to ensure their native dependencies are correctly compiled and compatible with the current Node.js runtime and host environment. It has been instrumental in enabling smoother transitions between Node.js versions and facilitating cross-platform development.


title: PARAMETERS
content:
<b>-port=<I>XXXX</I></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specifies the UDP port for game client connections. Default is usually <B>8211</B>.<br><br><b>-queryport=<I>XXXX</I></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Sets the UDP port for server list queries and status information. Default is often <B>8212</B>.<br><br><b>-players=<I>Y</I></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Defines the maximum number of players allowed on the server simultaneously. <br>The game's server configuration file (<I>PalWorldSettings.ini</I>) also contains this setting.<br><br><b>-RCONPort=<I>XXXX</I></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Configures the TCP port for Remote Console (RCON) administration. Used for remote server management commands.<br><br><b>-RCONEnabled=<I>true</I>|<I>false</I></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Enables or disables RCON functionality for server administration.<br><br><b>-log</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Enables detailed logging output from the server, often useful for debugging.<br><br><b>-useperfthreads</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Optimizes server performance by utilizing performance-oriented threads, potentially improving stability and responsiveness.<br><br><b>-NoAsyncLoadingThread</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Disables asynchronous loading threads, which can sometimes resolve specific loading or stability issues, though it might impact initial load times.<br><br><b>-UseHostNetSpeed</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Instructs the server to use the host machine's network speed settings, which can be relevant for network performance tuning.<br><br><b>-EpicApp=PalServer</b><br>&nbsp;&nbsp;&nbsp;&nbsp;A parameter often used internally by the server's launch scripts to identify the application.<br><br>


title: DESCRIPTION
content:
The term "palworld linux command" typically refers to running the <I>Palworld Dedicated Server</I> application on a Linux operating system, rather than a standalone Linux utility named "palworld". <br><br>Palworld is a popular open-world survival crafting game known for its creature collection and base-building elements. To host a game for multiple players, a dedicated server is often deployed. On Linux, this server application is usually installed via <I>SteamCMD</I> and invoked through a shell script (e.g., <B>PalServer.sh</B>) or directly via its executable (<B>PalServer</B>). This allows users to host their own persistent game worlds independent of a client application, providing a stable and customizable environment for gameplay.


title: CAVEATS
content:
The "palworld" command does not exist as a standard Linux utility. This analysis refers to the <I>Palworld Dedicated Server</I> executable and its arguments. Running the server requires significant system resources (CPU, RAM, disk I/O), and performance can vary based on the number of players and in-game activities. Server configuration is primarily managed through <I>PalWorldSettings.ini</I> and <I>DefaultPalWorldSettings.ini</I> files, with command-line arguments often overriding or supplementing these settings. Ensure proper port forwarding is configured on your network for external access.


title: INSTALLATION
content:
The Palworld Dedicated Server is typically installed on Linux using <B>SteamCMD</B>. <br>First, install <B>SteamCMD</B> itself. Then, log in anonymously and use the command <B>app_update 2394010 validate</B> to download the Palworld server files.


title: RUNNING AS A SERVICE
content:
For persistent and robust operation, it's common practice to run the Palworld server as a <B>systemd</B> service. This allows for automatic startup on boot, easy management (start, stop, restart), and logging directly through the system's journal (<B>journalctl</B>).


title: CONFIGURATION FILES
content:
While some settings can be passed via command-line arguments, the primary configuration for the Palworld server resides in <I>PalWorldSettings.ini</I> (and <I>DefaultPalWorldSettings.ini</I> for defaults) located in the <B>Pal/Saved/Config/LinuxServer/</B> directory within the server installation path. These files control game rules, server name, password, rates, and more.


title: HISTORY
content:
Palworld, developed by Pocketpair, was released in early access in January 2024. Following its highly successful launch, the demand for dedicated servers surged. The Linux dedicated server application was made available to facilitate self-hosting, allowing players and communities to run their own persistent Palworld instances. Its development history is tied directly to the game's rapid growth and the community's need for stable, customizable multiplayer environments beyond official servers.


title: SYNOPSIS
content:
<b>rabbitmq-diagnostics</b> <i>&lt;subcommand&gt;</i> [<i>&lt;subcommand_options&gt;</i>]<br>   [<i>--node &lt;node_name&gt;</i>]<br>   [<i>--longnames</i>]<br>   [<i>--silent</i>]<br>   [<i>--wait</i>]


title: PARAMETERS
content:
<b><i>status</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Displays the status of the local RabbitMQ node, including OS, Erlang, memory usage, open files, network connections, and running applications.<br><br><b><i>cluster_status</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Provides a summary of the RabbitMQ cluster, including cluster members, their health, defined policies, and queue master locations.<br><br><b><i>environment</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Shows the effective environment variables and their values used by the RabbitMQ node at startup.<br><br><b><i>erlang_cookie_paths</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Lists the possible locations where the Erlang cookie file might be found, which is crucial for inter-node communication and authentication.<br><br><b><i>node_health_check</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Performs a basic health check on the RabbitMQ node, verifying its operational state and readiness.<br><br><b><i>observer_cli</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Starts an Erlang Observer CLI session connected to the RabbitMQ node for detailed runtime inspection of Erlang processes.<br><br><b><i>listen_ports</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Displays the network ports the RabbitMQ node is currently listening on for client and inter-node communication.<br><br><b><i>log_config</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Shows the effective logging configuration for the RabbitMQ node, including log levels and destinations.<br><br><b><i>schema_info</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Provides information about the RabbitMQ internal database schema, including file locations and versions.<br><br><b><i>config_info</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Displays the effective configuration files, directories, and other system paths used by RabbitMQ.<br><br><b><i>net_tick_time</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Shows the Erlang <i>net_tick_time</i> value, which affects how often Erlang nodes check connectivity with each other.<br><br><b><i>--node &lt;node_name&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specifies the target RabbitMQ node (e.g., <i>rabbit@hostname</i>). Defaults to the local node. Can be used with most subcommands to target remote nodes.<br><br><b><i>--longnames</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Forces the use of long node names (e.g., <i>rabbit@host.fqdn</i>) instead of short names, which is important in mixed DNS environments.<br><br><b><i>--silent</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Suppresses output for commands that might normally print to stdout (use with caution as it hides diagnostic information).<br><br><b><i>--wait</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Makes the command wait for the target RabbitMQ node to be running and fully started before executing the specified subcommand.<br><br>


title: DESCRIPTION
content:
The <i>rabbitmq-diagnostics</i> command is a powerful utility for troubleshooting, monitoring, and inspecting the state of RabbitMQ nodes and clusters. Unlike <i>rabbitmqctl</i>, many of its commands can operate even if the RabbitMQ application itself is not fully started, making it invaluable for diagnosing issues with unresponsive or partially booting nodes. It provides detailed insights into node health, configuration, runtime metrics, network connectivity, Erlang environment, and cluster topology. Administrators and support personnel frequently use this tool to gather information essential for debugging and maintaining RabbitMQ deployments, often as the first step when a node exhibits unexpected behavior or fails to join a cluster properly.


title: CAVEATS
content:
The command requires correct file system permissions to access RabbitMQ's data directory, log files, and the Erlang cookie. When targeting remote nodes or using a non-standard Erlang cookie, ensure the cookie is correctly configured and accessible in the expected locations. Some subcommands (e.g., <i>cluster_status</i>) still require the RabbitMQ application to be running, while others (e.g., <i>erlang_cookie_paths</i>) can run earlier in the startup process. Network connectivity is essential for communicating with remote cluster members.


title: USAGE CONTEXT
content:
Use <i>rabbitmq-diagnostics</i> primarily when you need to gather information about a RabbitMQ node or cluster, especially if the node is not responding to <i>rabbitmqctl</i> commands or is failing to start. It's often the first tool to reach for when a node exhibits unexpected behavior, is unreachable, or has startup issues. For routine administration of a healthy and fully operational cluster, <i>rabbitmqctl</i> remains the go-to command.


title: ERLANG COOKIE IMPORTANCE
content:
For <i>rabbitmq-diagnostics</i> to communicate with a RabbitMQ node (local or remote), it typically requires access to the <b>Erlang cookie</b>. This cookie acts as a shared secret for authentication between Erlang nodes. If the command fails with 'badarg', 'nodedown', or similar errors related to node communication, verifying the Erlang cookie's presence and correct permissions is often the first troubleshooting step. The correct cookie path can be identified using the <i>erlang_cookie_paths</i> subcommand.


title: HISTORY
content:
<i>rabbitmq-diagnostics</i> was introduced to provide a more robust and granular set of tools for troubleshooting RabbitMQ nodes. While <i>rabbitmqctl</i> serves as the primary administrative interface, it often requires the RabbitMQ application to be fully operational. <i>rabbitmq-diagnostics</i> was specifically designed to gather critical information even when a node is partially started, unresponsive, or experiencing issues, making it an essential tool for deep-dive diagnostics and support scenarios. Its capabilities have expanded with successive RabbitMQ versions to cover more aspects of node and cluster health.


title: SYNOPSIS
content:
<b>rabbitmq-queues</b> <i>&lt;command&gt;</i> [<i>&lt;queue_name&gt;</i>...] [<i>&lt;options&gt;</i>]


title: PARAMETERS
content:
<b><b>list</b> [<i>&lt;queue_name&gt;</i>...]</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Lists queues and their properties. If specific queue names are provided, only those queues are detailed. Supports various output formats and column selections.<br><br><b><b>purge</b> <i>&lt;queue_name&gt;</i>...</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Removes all messages from one or more specified queues. This action is irreversible and should be used with caution.<br><br><b><b>delete</b> <i>&lt;queue_name&gt;</i>...</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Deletes one or more specified queues permanently. This action also purges any remaining messages in the queue and should be used carefully.<br><br><b>--vhost <I>&lt;vhost&gt;</I></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specifies the virtual host on which to perform the operation. Defaults to '/' if not specified.<br><br><b>--formatter <I>&lt;format&gt;</I></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Defines the output format. Common formats include <b>json</b>, <b>tsv</b> (tab-separated values), <b>raw</b>, and <b>long</b>.<br><br><b>--columns <I>&lt;cols&gt;</I></b><br>&nbsp;&nbsp;&nbsp;&nbsp;A comma-separated list of column names to display for <b>list</b> commands (e.g., <b>name,messages,consumers</b>).<br><br><b>--node <I>&lt;node&gt;</I></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Targets a specific RabbitMQ cluster node for the operation. By default, any online node is targeted.<br><br><b>--force</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Skips confirmation prompts for destructive operations like <b>purge</b> and <b>delete</b>.<br><br><b>--timeout <I>&lt;seconds&gt;</I></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Sets the maximum time in seconds to wait for the command to complete before exiting.<br><br><b>--online</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Operates only on queues that are currently online and available.<br><br><b>--offline</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Operates only on queues that are currently offline or unavailable.<br><br>


title: DESCRIPTION
content:
The <b>rabbitmq-queues</b> command-line tool provides a direct interface for inspecting and manipulating queues within a RabbitMQ cluster. It enables users to perform essential operational tasks such as listing, purging, and deleting queues. This command is particularly useful for scripting, automation, and quick diagnostics of queue states. While offering a dedicated set of functionalities for queues, its capabilities are largely mirrored, and in modern RabbitMQ versions, often superseded by the more comprehensive <b>rabbitmqctl</b> command-line utility. It interacts with the RabbitMQ broker, requiring appropriate user permissions to execute its operations successfully across specified virtual hosts or specific cluster nodes.


title: CAVEATS
content:
Using <b>rabbitmq-queues purge</b> or <b>delete</b> on production systems can lead to data loss and service disruption. Always exercise caution and ensure proper backups or testing procedures. This command requires appropriate RabbitMQ user permissions (e.g., <b>configure</b>, <b>read</b>, <b>write</b>) on the target virtual host and queues. Operations might be slow for queues with a very large number of messages or for clusters under heavy load. The command's functionality is often an alias or superseded by <b>rabbitmqctl</b> commands in modern RabbitMQ versions.


title: DEPRECATION AND MODERN ALTERNATIVES
content:
For modern RabbitMQ deployments, it is highly recommended to use <b>rabbitmqctl</b> for queue management. Commands like <b>rabbitmqctl list_queues</b>, <b>rabbitmqctl purge_queue</b>, and <b>rabbitmqctl delete_queue</b> offer equivalent or enhanced functionality and are the preferred methods for interacting with RabbitMQ queues via the command line.


title: PERMISSIONS REQUIRED
content:
To execute commands successfully, the user connecting to RabbitMQ must have sufficient permissions. For example, <b>list</b> requires <i>read</i> permissions, <b>purge</b> requires <i>write</i> permissions, and <b>delete</b> requires <i>configure</i> permissions on the target queues and virtual host.


title: OUTPUT FORMATTERS
content:
The <b>--formatter</b> option is powerful for scripting. <br><b>json</b>: Outputs data in a machine-readable JSON array of objects. <br><b>tsv</b>: Tab-separated values, useful for importing into spreadsheets or other tools. <br><b>raw</b>: Minimal output, often just values separated by spaces. <br><b>long</b>: A human-readable, multi-line format providing detailed information.


title: HISTORY
content:
The <b>rabbitmq-queues</b> command originated as a dedicated utility to streamline queue management tasks, offering a focused interface for common operational needs. Over time, as the RabbitMQ management ecosystem evolved, much of its functionality was integrated directly into the more comprehensive <b>rabbitmqctl</b> command. Consequently, in newer RabbitMQ versions, <b>rabbitmq-queues</b> is often considered a legacy tool, with its operations typically achievable through <b>rabbitmqctl list_queues</b>, <b>rabbitmqctl purge_queue</b>, and <b>rabbitmqctl delete_queue</b> commands, which provide a more unified and consistent management experience.


title: PARAMETERS
content:
<b>create &lt;stream-name&gt; [<I>options</I>]</b><br>&nbsp;&nbsp;&nbsp;&nbsp;<i>Creates a new stream</i> with the specified name. Optional configurations like <code>--max-length</code>, <code>--max-age</code>, or <code>--max-segment-size</code> can be applied during creation.<br><br><b>delete &lt;stream-name&gt;</b><br>&nbsp;&nbsp;&nbsp;&nbsp;<i>Deletes an existing stream</i> and irrevocably removes all its associated messages and metadata.<br><br><b>list</b><br>&nbsp;&nbsp;&nbsp;&nbsp;<i>Lists all streams</i> currently configured on the RabbitMQ broker, displaying their names, statuses, and basic properties.<br><br><b>purge &lt;stream-name&gt;</b><br>&nbsp;&nbsp;&nbsp;&nbsp;<i>Removes all messages from a stream</i>, effectively clearing its content while leaving the stream resource itself intact.<br><br><b>set-retention &lt;stream-name&gt; [<I>options</I>]</b><br>&nbsp;&nbsp;&nbsp;&nbsp;<i>Configures retention policies</i> for a specific stream. Options include <code>--max-age &lt;duration&gt;</code> (e.g., <code>1h</code>, <code>7d</code>) or <code>--max-length &lt;bytes&gt;</code> to control message expiration.<br><br><b>set-max-segment-size &lt;stream-name&gt; &lt;size&gt;</b><br>&nbsp;&nbsp;&nbsp;&nbsp;<i>Sets the maximum segment file size</i> for a stream (e.g., <code>100MB</code>, <code>1GB</code>). Segments are the underlying disk storage units for stream data.<br><br><b>status [<I>stream-name</I>]</b><br>&nbsp;&nbsp;&nbsp;&nbsp;<i>Displays the operational status and detailed configuration</i> of a specific stream or all streams if no name is provided.<br><br><b>node &lt;node-name&gt;</b><br>&nbsp;&nbsp;&nbsp;&nbsp;<i>Specifies the target RabbitMQ node</i> to connect to when performing operations, particularly useful in clustered environments to direct commands to a specific instance.<br><br><b>--help</b><br>&nbsp;&nbsp;&nbsp;&nbsp;<i>Displays help information</i> for the main command or a specific subcommand, showing available options and usage examples.<br><br>


title: DESCRIPTION
content:
The <b>rabbitmq-streams</b> command-line interface (CLI) tool is designed for interacting with and managing RabbitMQ Streams. RabbitMQ Streams represent a high-throughput, low-latency, and persistent messaging feature within RabbitMQ, offering a robust solution for scenarios demanding large, ordered event logs.<br><br>This utility empowers administrators and developers to perform essential operations directly on the RabbitMQ server, including the creation, deletion, listing, and configuration of streams. It is crucial for the complete lifecycle management of stream resources and for monitoring their status without exclusive reliance on client libraries or the RabbitMQ Management UI. Typically, <b>rabbitmq-streams</b> is distributed as part of the RabbitMQ server utilities, providing a direct and powerful means to control this advanced messaging capability.


title: CAVEATS
content:
For <b>rabbitmq-streams</b> to function, a running RabbitMQ server with the <b>rabbitmq_stream</b> plugin enabled is mandatory.<br>Operations performed via this CLI tool are direct server-side commands; they carry significant impact and should be exercised with extreme caution, especially in production environments, as they can lead to data modification or loss.<br>The tool's functionality is subject to RabbitMQ's authentication and authorization mechanisms, requiring appropriate user permissions.<br>The exact syntax, available subcommands, and options may exhibit slight variations across different RabbitMQ server versions.


title: STREAMS PLUGIN REQUIREMENT
content:
The fundamental prerequisite for using <b>rabbitmq-streams</b> is the activation of the <code>rabbitmq_stream</code> plugin on your RabbitMQ server. This can be achieved by running the command: <code>rabbitmq-plugins enable rabbitmq_stream</code>.


title: DATA STORAGE MECHANISM
content:
RabbitMQ Streams utilize an optimized, disk-backed storage mechanism, segmenting data into immutable files. This design ensures high performance for both writes and reads, guaranteeing persistence and efficient historical data replay. Understanding these underlying storage segments is vital for effective capacity planning, performance tuning, and troubleshooting.


title: CLIENT INTERACTION
content:
While <b>rabbitmq-streams</b> manages server-side stream resources, the actual publishing and consuming of messages to and from streams are primarily handled by dedicated client libraries. These libraries (available for languages like Java, .NET, etc.) implement the AMQP 1.0-based Stream Protocol, providing the necessary APIs for application-level interaction with streams.


title: HISTORY
content:
RabbitMQ Streams was introduced as a pivotal feature in RabbitMQ 3.9.0, marking a significant evolution in its messaging capabilities. This development aimed to provide a high-performance, disk-backed messaging system specifically designed for handling very large, immutable event logs. It addresses critical use cases such as event sourcing, IoT data ingestion, and log aggregation, offering robust persistence, ordered message delivery, and efficient replayability, distinguishing itself from traditional RabbitMQ queues.<br><br>The <b>rabbitmq-streams</b> command-line utility was developed concurrently with the Streams plugin. Its purpose is to equip administrators with a powerful, direct interface for managing and configuring these new stream resources from the command line, thereby complementing the RabbitMQ Management UI and the various client libraries.


title: SYNOPSIS
content:
<b><i>ShooterGameServer</i></b> <I>MapName</I>[<I>?listen</I>][<I>?SessionName=Name</I>...][<I>-useperfthreads</I>...]


title: PARAMETERS
content:
<b><i>MapName</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;The name of the specific ARK map to load (e.g., <i>TheIsland</i>, <i>ScorchedEarth_P</i>). This is the primary positional argument after the executable.<br><br><b><i>?listen</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;A required flag within the query string to instruct the server to accept client connections.<br><br><b><i>?SessionName=</i><I>name</I></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Sets the public display name of the server that appears in the game's server browser.<br><br><b><i>?Port=</i><I>portnum</I></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specifies the primary UDP game port (default <i>7777</i>) for client connections.<br><br><b><i>?QueryPort=</i><I>portnum</I></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specifies the UDP query port (default <i>27015</i>) used for server listing and status queries.<br><br><b><i>?ServerPassword=</i><I>password</I></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Sets a password required for players to join the server.<br><br><b><i>?ServerAdminPassword=</i><I>password</I></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Sets the administrator password, used for in-game console commands and RCON access.<br><br><b><i>?MaxPlayers=</i><I>num</I></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Defines the maximum number of players that can simultaneously be connected to the server.<br><br><b><i>?RCONPort=</i><I>portnum</I></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Enables and sets the RCON (Remote Console) TCP port (default <i>32330</i>) for remote administration.<br><br><b><i>?RCONEnabled=</i><I>True|False</I></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Activates or deactivates the RCON feature. Must be set to <i>True</i> for RCONPort to function.<br><br><b><i>-useperfthreads</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;A Unreal Engine flag optimizing server performance by utilizing additional CPU threads for various tasks.<br><br><b><i>-NoAsyncLoadingThread</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Disables asynchronous loading threads, which can improve stability on certain hardware configurations.<br><br><b><i>-UseMultithreadForDS</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Enables specific multi-threading optimizations for dedicated server operations, enhancing efficiency.<br><br><b><i>-structuredlog</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Outputs server logs in a structured format, making them easier to parse and analyze with tools.<br><br><b><i>-log</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Enables general logging to a file, providing verbose output for debugging and monitoring.<br><br><b><i>-NoBattlEye</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Disables the BattlEye anti-cheat system. Typically used for private testing or development, not recommended for public servers.<br><br><b><i>-multihome=</i><I>IP_address</I></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Binds the server to a specific local IP address, useful on machines with multiple network interfaces.<br><br>


title: DESCRIPTION
content:
The "ark-survival-ascended" command refers to the method of launching and managing a dedicated game server for Ark: Survival Ascended on a Linux system. While not a standalone Linux utility in the traditional sense, it conceptually represents the execution of the underlying Unreal Engine server executable, typically named <b><i>ShooterGameServer</i></b>. <br><br>This command is crucial for individuals or communities looking to host their own persistent Ark worlds, offering full control over game settings, mods, and player experience. The server executable is highly configurable, relying on a combination of command-line arguments for immediate settings (like map, ports, session name, passwords) and INI configuration files (<i>Game.ini</i>, <i>GameUserSettings.ini</i>) for more detailed gameplay rules, multipliers, and advanced server behaviors. <br><br>Setting up and running an Ark: Survival Ascended server involves installing the server files via SteamCMD, configuring network ports (port forwarding), and crafting the appropriate launch command with all desired parameters. It's known for being resource-intensive, requiring significant CPU, RAM, and storage, and often runs within a persistent session manager like <i>screen</i> or <i>tmux</i>, or as a <i>systemd</i> service.


title: CAVEATS
content:
The Ark: Survival Ascended server is resource-intensive, requiring substantial CPU, RAM, and disk I/O.<br>Configuration is split between command-line arguments and multiple INI files, which can be complex.<br>Regular game updates necessitate frequent server updates and restarts, potentially causing downtime.<br>Requires proper port forwarding on the host machine's firewall and router for external access.<br>Performance can vary significantly based on hardware, player count, and installed mods.


title: INI FILE CONFIGURATION
content:
Many advanced server settings, gameplay rules, multipliers, and mod configurations are managed through INI files located in the server's configuration directory (e.g., <i>Game.ini</i>, <i>GameUserSettings.ini</i>). Command-line arguments often override or supplement these settings.


title: INSTALLATION AND UPDATES
content:
The server files are typically installed and updated using Valve's <i><b>SteamCMD</b></i> utility. This command-line tool allows for automated download and maintenance of dedicated game server files, ensuring the server remains current with the latest game version.


title: RUNNING AS A BACKGROUND PROCESS
content:
For continuous operation, it's common practice to run the server within a terminal multiplexer like <i><b>screen</b></i> or <i><b>tmux</b></i>, or configure it as a <i><b>systemd</b></i> service. This ensures the server continues to run even if the user logs out and provides robust management capabilities.


title: HISTORY
content:
The dedicated server for Ark: Survival Ascended (ASA) is the latest iteration of server technology that originated with Ark: Survival Evolved (ASE). Both games, developed by Studio Wildcard, utilize the Unreal Engine, dictating a similar command-line interface for server setup. The `ShooterGameServer` executable has been the core server binary since ASE's launch in 2015. With ASA's move to Unreal Engine 5, the server's underlying architecture was updated, but the command-line arguments and configuration file structure largely remained consistent, reflecting a mature and evolved approach to game server deployment on Linux.


title: TLDR
content:
<b>Start the server with a specific map</b>`[path/to/ArkAscendedServer] [TheIsland_WP]`<br><b>Start the server with a specific session name, server password, and admin password</b>`[path/to/ArkAscendedServer] [TheIsland_WP]?SessionName=[session_name]?ServerPassword=[server_password]?ServerAdminPassword=[admin_password]`<br><b>Start the server with a specific port and set a maximum player count</b>`[path/to/ArkAscendedServer] [TheIsland_WP] -port=[7777] -WinLiveMaxPlayers=[1..70]`<br><b>Enable PvE and disabling PvP</b>`[path/to/ArkAscendedServer] [TheIsland_WP]?ServerPVE=true`<br><b>Set a multiplier to scale the server difficulty, affecting the maximum level of wild creatures</b>`[path/to/ArkAscendedServer] [TheIsland_WP]?DifficultyOffset=[1.0]`<br><b>Disable creature animation optimization to prevent collision issues</b>`[path/to/ArkAscendedServer] [TheIsland_WP] -AlwaysTickDedicatedSkeletalMeshes`<br><b>Enable specific mods by their ID (comma-separated)</b>`[path/to/ArkAscendedServer] [TheIsland_WP] -mods=[mod_id1, mod_id2, ...]`<br><b>Allow connections from specific platforms</b>`[path/to/ArkAscendedServer] [TheIsland_WP] -ServerPlatform=[PC+XSX+PS5]`


title: PARAMETERS
content:
<b><i>--help</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Displays a help message and exits, detailing available command-line options for <i>bluetui</i>.<br><br><b><i>--version</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Shows the program's version number and exits.<br><br><b><i>--debug</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Enables debug logging, providing more verbose output to the console for troubleshooting purposes.<br><br>


title: DESCRIPTION
content:
<i>bluetui</i> is an interactive Terminal User Interface (TUI) written in Python for managing Bluetooth devices on Linux systems. It provides a more user-friendly and visual alternative to traditional command-line tools like <i>bluetoothctl</i> by presenting a console-based graphical interface. Within its interactive environment, users can easily scan for nearby Bluetooth devices, initiate pairing, establish and terminate connections, and manage various Bluetooth adapters and peripherals directly. It leverages the powerful BlueZ protocol stack, which is the official Linux Bluetooth stack, offering an intuitive yet robust way to handle all essential Bluetooth operations without needing to switch away from the terminal.


title: CAVEATS
content:
<i>bluetui</i> is typically installed via <i>pip</i> (Python Package Installer) and may not be pre-installed on all Linux distributions. It requires Python 3 and the BlueZ Bluetooth stack to be operational on the system. All significant interactions and device management, such as pairing or connecting, occur within its interactive TUI after launch, not as direct command-line arguments to <i>bluetui</i> itself.


title: INTERACTIVE USAGE
content:
Once launched, <i>bluetui</i> presents an interactive console where users navigate using arrow keys, tabs, and specific hotkeys (e.g., 'q' to quit, 'd' to disconnect, 'p' to pair). All Bluetooth operations, from scanning to connecting, are performed within this dynamic environment, offering a distinct experience compared to executing single-shot commands.


title: HISTORY
content:
<i>bluetui</i> emerged as a modern, Python-based solution to simplify Bluetooth management within the Linux terminal. Its development focuses on providing a more visual and interactive experience, moving beyond the often terse output of traditional command-line utilities. By leveraging the robust BlueZ backend and offering a TUI, it aims to make Bluetooth device handling more accessible and user-friendly for those who prefer console-based applications.


title: SYNOPSIS
content:
<b>koji build</b> <<i>build-target</i>> <<i>source</i>> [<i>options</i>]<br><br>Where:<br> <<i>build-target</i>> specifies the Koji tag/target for the build.<br> <<i>source</i>> can be an SRPM file path, an URL to an SRPM, or a Git repository URL (e.g., <i>git+https://example.com/repo#branch=master&committish=HEAD&path=foo.spec</i>).


title: PARAMETERS
content:
<b>--scratch</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Performs a temporary "scratch" build that is not permanently tagged or saved in Koji's official records. Ideal for testing.<br><br><b>--wait</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Blocks the command execution until the submitted build task has completed, failed, or been canceled.<br><br><b>--nowait</b><br>&nbsp;&nbsp;&nbsp;&nbsp;(Default) Submits the build task to Koji and immediately exits without waiting for completion.<br><br><b>--arch <<i>arch</i>></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specifies a comma-separated list of architectures on which to build. If not specified, Koji builds for all architectures defined by the target.<br><br><b>--skip-tag</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Prevents the resulting build from being automatically tagged into the specified <<i>build-target</i>> upon successful completion.<br><br><b>--rebuild</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Forces a rebuild of a package even if a build for the same NVR (Name-Version-Release) already exists in Koji.<br><br><b>--force</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Similar to <i>--rebuild</i>, but may also bypass other checks that prevent duplicate or unnecessary builds.<br><br><b>--build-id <<i>id</i>></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Assigns a specific build ID to the Koji build task.<br><br><b>--signing-env <<i>env</i>></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specifies the signing environment to be used for signing the resulting RPMs.<br><br><b>--message <<i>msg</i>></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Adds a custom message or note to the build task, visible in Koji logs.<br><br><b>--background</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Runs the build in the background, similar to <i>--nowait</i>, but explicitly states the intent.<br><br><b>--priority <<i>level</i>></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Sets the priority of the build task in the Koji queue (e.g., 0 for default, higher numbers for higher priority).<br><br><b>--request</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Requests a build for an existing package/NVR, typically used in specific Koji workflows.<br><br><b>--fail-fast</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Causes the build to fail immediately if any part of the build process encounters an error, without attempting subsequent steps.<br><br><b>--no-clean</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Retains the build root on the build host after a failed build, useful for debugging.<br><br><b>--release <<i>string</i>></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Overrides the release string typically derived from the spec file.<br><br><b>--token <<i>token</i>></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Provides an authentication token for Koji, useful for automation without password prompts.<br><br><b>--config <<i>file</i>></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specifies an alternative Koji configuration file to use.<br><br>


title: DESCRIPTION
content:
<b>koji-build</b> is a command-line utility used to initiate builds within the Koji build system, a distributed and trusted build environment primarily used for RPM-based Linux distributions like Fedora and RHEL.<br><br>It enables developers and release engineers to submit source RPMs (SRPMs) or source Git repositories to the Koji hub, which then orchestrates the build process on various build hosts. The command ensures that packages are built consistently within defined build roots, using specific compilers, libraries, and build tools, producing official binary RPMs. It supports both permanent, tagged builds and temporary "scratch" builds for testing purposes, making it an essential tool for maintaining the integrity and reproducibility of software packages in large-scale projects.


title: CAVEATS
content:
Requires proper Koji client configuration and authentication credentials to connect to the Koji hub.<br>Builds consume significant resources on build hosts; excessive or unoptimized builds can impact system performance.<br>Understanding Koji build targets, tags, and inheritance is crucial for correct package management and release processes.<br>Scratch builds are not archived long-term and do not contribute to official package releases.


title: BUILD TARGETS AND TAGS
content:
Koji uses "build targets" to define the environment and destination for a build. A target typically corresponds to a Koji tag, which acts as a collection point for successful builds. Packages built against a specific target are usually automatically tagged into it, making them available for further processes like composing repositories or creating distributions. Tags can inherit packages from other tags, forming complex release hierarchies.


title: SOURCE REPRESENTATION
content:
The <<i>source</i>> argument for <b>koji-build</b> is versatile. While often an SRPM file, it increasingly supports Git repository URLs, allowing Koji to checkout source code directly from a specified branch, commit, or tag, and then extract the spec file and source tarballs to initiate a build. This Git integration streamlines development workflows and ensures that builds are tied directly to specific points in a version control history.


title: HISTORY
content:
Koji was developed by Red Hat as a robust, scalable, and secure build system to replace older, less automated methods for building RPM packages for Fedora and later RHEL. Its development started in the early 2000s, driven by the need for a standardized, auditable, and distributed build infrastructure for a large open-source project. The <b>koji-build</b> command is central to its operation, providing the primary interface for users to submit build requests to this system, ensuring consistency and reproducibility across vast numbers of packages and architectures.


title: TLDR
content:
<b>Build a package from src.rpm</b>`koji build [target] [path/to/src.rpm]`<br><b>Build a package from a SCM (Source Code Management) URL</b>`koji build [target] [git+https://src.fedoraproject.org/rpms/vim.git#e847a50297a216229050bf4db3d06a139104e7cf]`<br><b>Perform a scratch build</b>`koji build [target] [path/to/src.rpm] --scratch`<br><b>Wait on the build, even if it's running in the background</b>`koji build [target] [path/to/src.rpm] --wait`<br><b>Don't wait on build</b>`koji build [target] [path/to/src.rpm] --nowait`<br><b>Display help</b>`koji build --help`


title: SYNOPSIS
content:
<b>koji</b> [<I>GLOBAL_OPTIONS</I>] <I>COMMAND</I> [<I>COMMAND_OPTIONS</I>] [<I>ARGUMENTS</I>]<br><br>Examples:<br><b>koji</b> --help<br><b>koji</b> build --target=<I>f38-build</I> <I>git://example.com/rpms/foo#master</I><br><b>koji</b> list-builds --package=<I>httpd</I>


title: PARAMETERS
content:
<b><b>--help</b>, <b>-h</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Display a help message for the <b>koji</b> command or a specific subcommand.<br><br><b><b>--version</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Show the program's version number and exit.<br><br><b><b>--config</b>=<I>file</I></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specify an alternate configuration file to use instead of the default (~/.koji/config).<br><br><b><b>--profile</b>=<I>name</I></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Select a specific profile from the configuration file. Useful for switching between different Koji instances or user accounts.<br><br><b><b>--server</b>=<I>URL</I></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Override the Koji XMLRPC server URL specified in the configuration file.<br><br><b><b>--weburl</b>=<I>URL</I></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Override the Koji web interface URL specified in the configuration file.<br><br><b><b>--force</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Proceed with operations that might otherwise require confirmation or be blocked by checks.<br><br><b><b>--debug</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Enable debug output, providing more detailed information about command execution.<br><br><b><b>--quiet</b>, <b>-q</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Suppress informational output, showing only errors or requested data.<br><br>


title: DESCRIPTION
content:
The <B>koji</B> command is the primary client-side interface for interacting with the <B>Koji</B> build system. <B>Koji</B> is a powerful, distributed, and auditable build system used by projects like Fedora and Red Hat Enterprise Linux to build RPM packages.<br>It provides functionalities to submit new builds, monitor their progress, list existing builds, manage tags, query build information, and interact with the Koji hub and builders. It facilitates creating consistent and reproducible build environments, often integrating with tools like <I>mock</I> for isolated builds.


title: CAVEATS
content:
Requires a properly configured Koji client, typically located at <I>~/.koji/config</I>, with valid authentication credentials.<br>Network connectivity to the Koji hub server is essential for all operations.<br>User permissions on the Koji hub dictate which operations can be performed. Insufficient permissions will result in errors.<br>The command has many subcommands, each with its own set of options, which can make initial usage complex.


title: CONFIGURATION FILES
content:
The <B>koji</B> client relies on configuration files, typically <I>~/.koji/config</I> and potentially other files in <I>/etc/koji.conf.d/</I>. These files define connection details to the Koji hub, user authentication information (e.g., certificates), and default profiles. Different profiles can be used to connect to different Koji instances or with different user identities.


title: KOJI ARCHITECTURE
content:
Koji consists of several components:<br><b>Hub</b>: The central server that manages builds, tags, users, and provides the XMLRPC API.<br><b>Builders</b>: Machines that perform the actual RPM package builds in isolated <I>mock</I> environments.<br><b>Web Interface</b>: A web-based front-end for viewing build status, logs, and other Koji data.<br><b>Client</b>: The <B>koji</B> command-line tool used to interact with the Hub.


title: SUBCOMMANDS AND THEIR OPTIONS
content:
The <B>koji</B> command operates through a variety of subcommands, each performing a specific task (e.g., <I>build</I>, <I>list-builds</I>, <I>tag-build</I>). Each subcommand has its own set of unique options and arguments. For example, the <I>build</I> subcommand accepts options like <I>--target</I>, <I>--scratch</I>, and <I>--nowait</I>. To view options for a specific subcommand, use <B>koji</B> <I>COMMAND</I> <B>--help</B> (e.g., <B>koji</B> build <B>--help</B>).


title: HISTORY
content:
The <B>Koji</B> build system was developed by Red Hat and the Fedora Project to serve as the official build system for the Fedora Linux distribution. It was introduced to address the growing needs for a robust, scalable, and transparent system for building RPM packages for a large-scale operating system. It became the primary build system for Fedora around 2006, replacing older, less automated methods. Its design emphasizes isolated builds using <I>mock</I> and comprehensive tracking of build metadata.


title: TLDR
content:
<b>Execute a koji subcommand</b>`koji [subcommand]`<br><b>Introduce yourself to test connectivity with koijhub</b>`koji moshimoshi`<br><b>Display help about global options</b>`koji --help`<br><b>Display help to get all available commands</b>`koji help`<br><b>Display help for a specific subcommand (like build, tag-build, download-build, buildinfo,call, etc.)</b>`koji [subcommand] --help`<br><b>Display version</b>`koji version`


title: PARAMETERS
content:
<b>-h, --help</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Show a help message and exit.<br><br><b>-v, --version</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Show version information and exit.<br><br><b>-c <path>, --config <path></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specify an alternative path to the configuration file. Defaults to <i>~/.config/mako/config</i>.<br><br><b>-r, --reload</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Send a signal to a running mako instance to reload its configuration file.<br><br><b>--ipc-only</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Run without displaying any notifications, only listen for IPC commands (e.g., for `mako --reload`).<br><br><b>--markup <pango|none></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Control Pango markup parsing in notification bodies. Can be 'pango' (default) or 'none'.<br><br>


title: DESCRIPTION
content:
Mako is a <b>lightweight</b> and <b>highly configurable</b> notification daemon designed specifically for Wayland compositors. It listens for notifications sent via the <i>org.freedesktop.Notifications</i> D-Bus interface and displays them on the screen. <br><br>As a simple and efficient tool, Mako allows extensive customization of notification appearance, position, and behavior primarily through its configuration file. It's a popular choice for Wayland desktop environments due to its native Wayland support and seamless integration with compositors like Sway. Mako aims to provide a reliable and unobtrusive way to receive system and application notifications without being resource-intensive, focusing on minimal overhead and high customizability.


title: CAVEATS
content:
Mako is a <b>Wayland-only</b> notification daemon and will not function on X11-based desktop environments. Its extensive configuration is primarily handled via a dedicated configuration file, making command-line options limited to general controls. It does not natively support interactive buttons within notifications, though click actions can be configured.


title: CONFIGURATION FILE
content:
Mako's behavior and appearance are extensively controlled via a plain-text configuration file, typically located at <i>~/.config/mako/config</i>. This file allows users to define parameters such as fonts, colors, positions, sizes, borders, timeouts, and specific rules for different types of notifications, offering unparalleled customization.


title: D-BUS INTEGRATION
content:
Mako communicates using the standard <i>org.freedesktop.Notifications</i> D-Bus specification. This ensures compatibility with a wide range of applications that send standard desktop notifications, allowing Mako to display alerts from various sources across the system.


title: HISTORY
content:
Mako emerged as a native Wayland notification daemon, designed to fill the void for a simple, efficient, and highly configurable notification solution within the Wayland ecosystem. It is often associated with <i>wlroots</i>-based compositors like Sway, providing a seamless and performant experience for users transitioning away from X11. Its development emphasizes Wayland-specific features and minimal resource usage.


title: TLDR
content:
<b>Start the mako notification daemon</b>`mako`<br><b>Start with a custom configuration file</b>`mako [[-c|--config]] [path/to/config]`<br><b>Set maximum number of visible notifications</b>`mako --max-visible [5]`<br><b>Set default timeout in milliseconds (0 to disable)</b>`mako --default-timeout [2000]`<br><b>Group notifications by application name</b>`mako --group-by [app_name]`<br><b>Display help</b>`mako [[-h|--help]]`


title: DESCRIPTION
content:
The <I>makoctl-dismiss</I> command is a subcommand of the <I>makoctl</I> utility, which serves as the control interface for the <I>mako</I> Wayland notification daemon. Its primary function is to remove or hide active notifications displayed by <I>mako</I> from the user's screen. Users can choose to dismiss a specific notification by providing its unique identifier (ID) as an argument. If no ID is supplied, the command will clear all currently active notifications. This makes it a crucial tool for managing the on-screen clutter from applications, allowing users to quickly interact with or remove notifications once they have been seen or are no longer relevant. It operates asynchronously, sending a D-Bus message to the running <I>mako</I> daemon to perform the dismissal.


title: CAVEATS
content:
<I>makoctl-dismiss</I> operates exclusively within a Wayland environment, as <I>mako</I> itself is a Wayland-native notification daemon. It requires the <I>mako</I> daemon to be actively running to function. Notifications are dismissed from the display, but this action does not inherently communicate back to the originating application unless the application specifically listens for D-Bus notification close signals. There is no direct "undo" mechanism for a dismissed notification; once cleared, it cannot be brought back without the originating application sending a new notification.


title: RETRIEVING NOTIFICATION IDS
content:
To dismiss a specific notification, you need its unique ID. These IDs can be obtained by running the command `<b>makoctl list</b>`, which outputs a list of all active notifications along with their respective IDs. You can then use one or more of these IDs with `<b>makoctl dismiss</b>`.


title: HISTORY
content:
<I>Mako</I> was developed as a lightweight, highly customizable, and Wayland-native notification daemon, gaining popularity in minimalistic Wayland setups like those using Sway or Hyprland. The <I>makoctl</I> utility, including its <I>dismiss</I> subcommand, was introduced as an essential part of the <I>mako</I> project to provide a command-line interface for interaction. This allows users to programmatically control notifications, enabling scripting and integration with other system management tools or keybindings for efficient notification management in a Wayland desktop environment.


title: TLDR
content:
<b>Dismiss the most recent notification</b>`makoctl dismiss`<br><b>Dismiss a specific notification by ID</b>`makoctl dismiss -n [notification_id]`<br><b>Dismiss all notifications</b>`makoctl dismiss [[-a|--all]]`<br><b>Dismiss all notifications in the first group</b>`makoctl dismiss [[-g|--group]]`<br><b>Dismiss without adding to history</b>`makoctl dismiss [[-h|--no-history]]`


title: PARAMETERS
content:
<b><I>notification-id</I></b><br>&nbsp;&nbsp;&nbsp;&nbsp;The unique numerical ID of the notification to perform the action on. This ID can often be seen in Mako's output or retrieved via <code>makoctl list</code>. If omitted, the action is usually applied to the most recently updated notification that supports the specified action.<br><br><b><I>action-name</I></b><br>&nbsp;&nbsp;&nbsp;&nbsp;The name of the action to invoke. This name must correspond to an action defined in Mako's configuration file (e.g., <code>reply</code>, <code>dismiss</code>, or custom actions like <code>email</code>).<br><br>


title: DESCRIPTION
content:
<b>makoctl-invoke</b> is a subcommand of the <b>makoctl</b> utility, designed to programmatically trigger actions associated with notifications managed by the Mako Wayland notification daemon.<br><br>Users can define custom actions within Mako's configuration file (e.g., <code>~/.config/mako/config</code>) using <code>[action:&lt;name&gt;]</code> sections. These actions might include replying to messages, dismissing notifications, or opening specific applications. The <b>invoke</b> command allows these defined actions to be executed externally, for instance, via keyboard shortcuts managed by a Wayland compositor (like Sway or Hyprland) or through custom scripts.<br><br>It can target a specific notification using its unique ID, ensuring the action is applied precisely where intended. If no notification ID is provided, Mako typically attempts to apply the action to the most recently displayed notification that supports it. This functionality provides a powerful way to integrate Mako notifications into a user's workflow and custom automation.


title: CAVEATS
content:
<ul><li>Requires a running <code>mako</code> daemon instance for the command to operate.</li><li>The specified <code>action-name</code> must be pre-defined and enabled in Mako's configuration file.</li><li>If <code>notification-id</code> is provided but the notification no longer exists or does not support the action, the command might fail or have no effect.</li><li>Behavior when <code>notification-id</code> is omitted depends on the specific action and the currently active notifications in Mako.</li></ul>


title: DEFINING MAKO ACTIONS
content:
Actions in Mako are configured in the <code>~/.config/mako/config</code> file under <code>[action:&lt;name&gt;]</code> sections. These sections specify what command or script to execute when the action is invoked. For example:<br><code>[action:reply]<br>command=foot -e mutt -i %b %s</code> (This is a simplified example; actual action definitions might vary and use placeholders like <code>%b</code> for body, <code>%s</code> for subject, etc., depending on the notification content).


title: RETRIEVING NOTIFICATION IDS
content:
To target a specific notification with <b>makoctl-invoke</b>, you often need its ID. This can be obtained using <b>makoctl list</b>, which outputs a list of active notifications along with their unique IDs. For example, <code>makoctl list | grep "ID:"</code> can help in finding the ID of a notification you wish to interact with.


title: HISTORY
content:
Mako is a relatively recent addition to the Wayland ecosystem, designed to provide simple, customizable, and lightweight notifications. The <b>makoctl</b> utility, including its <b>invoke</b> subcommand, was developed to give users and scripts programmatic control over the daemon and its notifications. Its emergence reflects the growing need for robust inter-process communication and automation within the Wayland environment, allowing for deep integration with compositors and other desktop components.


title: TLDR
content:
<b>Invoke the default action on the most recent notification</b>`makoctl invoke`<br><b>Invoke a specific action on a notification (if not specified, default is used)</b>`makoctl invoke -n [notification_id] [action_name]`


title: SYNOPSIS
content:
<b>makoctl</b> mode list<br><b>makoctl</b> mode add <i>&lt;mode&gt;</i><br><b>makoctl</b> mode rm <i>&lt;mode&gt;</i><br><b>makoctl</b> mode activate <i>&lt;mode&gt;</i><br><b>makoctl</b> mode deactivate


title: PARAMETERS
content:
<b><b>list</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Lists all currently configured notification modes.<br><br><b><b>add</b> <i>&lt;mode&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Adds a new notification mode named <i>&lt;mode&gt;</i>. This makes the mode name available for configuration in Mako's config file.<br><br><b><b>rm</b> <i>&lt;mode&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Removes the notification mode named <i>&lt;mode&gt;</i>. If the mode is active, it will be deactivated first.<br><br><b><b>activate</b> <i>&lt;mode&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Activates the notification mode named <i>&lt;mode&gt;</i>. Any previously active modes will be deactivated.<br><br><b><b>deactivate</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Deactivates all currently active notification modes, returning Mako to its default behavior.<br><br>


title: DESCRIPTION
content:
The <b>makoctl mode</b> subcommand is used to control and manage how Mako, the Wayland notification daemon, displays notifications across different display modes.<br><br>Modes allow users to define distinct sets of notification rules (e.g., showing all, hiding some, or muting entirely) that can be toggled on or off, often based on specific contexts like presenting, gaming, or general work. This command enables listing available modes, adding new ones, removing existing ones, activating a particular mode, or deactivating all active modes.<br><br>It provides flexibility in customizing notification behavior dynamically without restarting the daemon or manually editing configuration files. This dynamic control is essential for adapting notification behavior to various user activities and preferences, ensuring a less disruptive computing experience on Wayland systems.


title: CAVEATS
content:
This command assumes you are referring to the <b>makoctl mode</b> subcommand of the Mako Wayland notification daemon, as 'makoctl-mode' is not a standard standalone Linux command.<br><br>For modes to have an effect, their behavior (e.g., hiding notifications, changing style) must be defined within Mako's configuration file (typically <i>~/.config/mako/config</i>). The <b>makoctl mode</b> command only manages the active state of these named modes.<br><br>Mako daemon must be running for these commands to function and for changes to take effect.


title: CONFIGURATION FOR MODES
content:
To make a mode effective, specific rules must be defined for it in Mako's configuration file, typically <i>~/.config/mako/config</i>. For example, a <code>[mode=dnd]</code> section could specify <code>invisible=1</code> to hide all notifications when "dnd" mode is active. Without corresponding configuration, adding or activating a mode will have no visible effect on notification behavior.


title: INTEGRATION WITH WAYLAND COMPOSITORS
content:
The <b>makoctl mode</b> command is commonly integrated into Wayland compositor configurations (e.g., Sway, Hyprland) using keybindings or status bar scripts. This allows users to quickly toggle notification modes based on their current activity, enhancing workflow efficiency and reducing distractions.


title: HISTORY
content:
Mako is a relatively modern Wayland-native notification daemon, designed to be lightweight and highly configurable. The <b>makoctl</b> utility, including its <b>mode</b> subcommand, was introduced as part of Mako's development to provide a dynamic way for users and scripts to interact with and control the daemon's behavior without needing to restart it or directly manipulate configuration files. This capability is crucial for environments where notification display needs to adapt quickly, such as during screen sharing or gaming sessions, allowing for immediate state changes.


title: TLDR
content:
<b>List all currently active modes</b>`makoctl mode`<br><b>Add a mode</b>`makoctl mode -a [do-not-disturb]`<br><b>Remove a mode</b>`makoctl mode -r [do-not-disturb]`<br><b>Toggle a mode (add if absent, remove if present)</b>`makoctl mode -t [do-not-disturb]`<br><b>Set specific modes, replacing all current modes</b>`makoctl mode -s [mode1 mode2 ...]`


title: PARAMETERS
content:
<b><b>-h, --help</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;<i>Display a help message and exit.</i><br><br><b><b>-v, --version</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;<i>Display version information and exit.</i><br><br><b><b>dismiss</b> [<i>id</i>...]</b><br>&nbsp;&nbsp;&nbsp;&nbsp;<i>Dismisses one or more notifications by their ID. If no IDs are specified, all notifications are dismissed.</i><br><br><b><b>restore</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;<i>Restores the last dismissed notification.</i><br><br><b><b>list</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;<i>Lists all currently active notifications, showing their IDs and content.</i><br><br><b><b>reload</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;<i>Reloads the Mako configuration file, applying changes without restarting the daemon.</i><br><br><b><b>set</b> <i>category</i>:<i>property</i>=<i>value</i> [...]</b><br>&nbsp;&nbsp;&nbsp;&nbsp;<i>Dynamically sets one or more properties for a specified notification category. E.g., `set '*' background-color=#282828`.</i><br><br><b><b>get</b> <i>category</i>:<i>property</i> [...]</b><br>&nbsp;&nbsp;&nbsp;&nbsp;<i>Retrieves the current value of one or more properties for a specified notification category.</i><br><br><b><b>help</b> [<i>command</i>]</b><br>&nbsp;&nbsp;&nbsp;&nbsp;<i>Displays specific help for a given command.</i><br><br>


title: DESCRIPTION
content:
<i><b>makoctl</b> is the command-line utility used to interact with a running Mako notification daemon instance. Mako is a lightweight and highly configurable Wayland-native notification daemon. <b>makoctl</b> allows users to perform various actions such as listing currently displayed notifications, dismissing them, restoring the last dismissed one, and dynamically querying or updating Mako's configuration and rules. It's an indispensable tool for managing the appearance and behavior of pop-up notifications without restarting the daemon, making it crucial for dynamic configuration adjustments and notification management in a Wayland environment.</i>


title: CAVEATS
content:
<i><b>makoctl</b> requires a running Mako daemon instance to operate. Configuration changes made using the `<b>set</b>` command are temporary and will be lost if Mako is restarted or if the configuration is reloaded from the file (e.g., via `<b>makoctl reload</b>`), unless these changes are persisted in the Mako configuration file (typically `~/.config/mako/config`). <b>makoctl</b> and Mako are primarily designed for Wayland compositors.</i>


title: DYNAMIC CONFIGURATION WITH `SET` AND `GET`
content:
<i>The `<b>set</b>` and `<b>get</b>` commands are powerful for live configuration adjustments. They operate on 'categories' (e.g., `*` for all notifications, `critical` for critical ones, or custom categories defined by `notify-send`) and 'properties' (e.g., `background-color`, `border-color`, `text-color`, `font`, `width`, `height`, etc.). For example, `<b>makoctl set '*' background-color=#282828</b>` changes the background for all notifications, and `<b>makoctl get critical text-color</b>` retrieves the text color for critical notifications. These changes are immediate but not persistent.</i>


title: NOTIFICATION IDS
content:
<i>When notifications are listed with `<b>makoctl list</b>`, they are assigned unique IDs. These IDs can then be used with the `<b>dismiss</b>` command to close specific notifications. IDs are transient and reset when Mako restarts.</i>


title: HISTORY
content:
<i>Mako was developed as a modern, Wayland-native notification daemon, fitting into the minimalist and customizable philosophy prevalent in the `swaywm` ecosystem and other Wayland environments. It emerged to fill the need for a simple, standards-compliant notification server without the baggage of older X11-focused solutions. <b>makoctl</b> was introduced as its dedicated command-line interface, providing users with fine-grained control over the daemon's runtime behavior and notification management, emphasizing dynamic configurability.</i>


title: TLDR
content:
<b>List all current notifications</b>`makoctl list`<br><b>List notification history</b>`makoctl history`<br><b>Reload the configuration file</b>`makoctl reload`<br><b>Restore the most recently expired notification from history</b>`makoctl restore`<br><b>Display help</b>`makoctl help`


title: PARAMETERS
content:
<b><I>UNIT</I></b><br>&nbsp;&nbsp;&nbsp;&nbsp;<i>The name of the systemd unit (e.g., `apache.service`, `user@1000.service`) whose properties are to be modified.</i><br><br><b><I>PROPERTY=VALUE</I></b><br>&nbsp;&nbsp;&nbsp;&nbsp;<i>One or more assignments of a property name to its new value. Example: `CPUShares=500`. Multiple property assignments can be provided, separated by spaces.</i><br><br>


title: DESCRIPTION
content:
`systemctl set-property` allows administrators to dynamically adjust the properties of active systemd units, such as services, sockets, or slices, without requiring a restart of the unit or modification of its configuration file. This command is particularly useful for runtime resource management, enabling real-time adjustments to settings like CPU shares (<b><i>CPUShares</i></b>), memory limits (<b><i>MemoryLimit</i></b>), or I/O weights (<b><i>IOWeight</i></b>) for specific services or user sessions.<br><br>Changes made using `set-property` are immediate and affect the running instance of the unit. However, it's crucial to understand that these modifications are <b><i>temporary</i></b>. They are held in memory and will be lost upon the unit's restart or a system reboot. For permanent changes, the unit's configuration file must be edited, typically using `systemctl edit`. This command empowers fine-grained control over system resources and behavior during operation, aiding in troubleshooting, performance tuning, or adapting to changing workload demands without service interruption.


title: CAVEATS
content:
<ul><li><b><i>Temporary Changes:</i></b> Modifications are only active for the current runtime and will be lost if the unit is stopped/restarted or the system reboots. They do not alter the unit's configuration file on disk.</li><li><b><i>Permissions:</i></b> Requires root privileges (or appropriate D-Bus permissions) to modify properties of system units. Users can usually modify properties of their own user units.</li><li><b><i>Not All Properties Settable:</i></b> Only certain properties are designed to be changed at runtime. Attempting to set an invalid or non-runtime-settable property will result in an error.</li><li><b><i>Immediate Impact:</i></b> Changes take effect immediately on the running unit, which can have an instant impact on its resource consumption or behavior.</li><li><b><i>Validation:</i></b> Systemd performs some validation, but incorrect values can still lead to unexpected behavior or unit instability.</li></ul>


title: <I>MAKING CHANGES PERMANENT</I>
content:
<i>To persist changes across reboots or unit restarts, you must edit the unit's configuration file. The recommended way is to use `systemctl edit <I>UNIT</I>`, which creates an override file in `/etc/systemd/system/` (or `~/.config/systemd/user/` for user units). After editing, run `systemctl daemon-reload` and then `systemctl restart <I>UNIT</I>` (if applicable).</i>


title: <I>LISTING SETTABLE PROPERTIES</I>
content:
<i>To identify properties that can be set for a specific unit type, consult the relevant systemd manual pages, such as `man systemd.resource-control(5)` for resource limits, `man systemd.service(5)` for service-specific properties, or `man systemd.slice(5)` for slice properties. Not all properties listed in these manuals are runtime-settable.</i>


title: HISTORY
content:
The `set-property` subcommand is an integral part of systemd's comprehensive approach to process and service management, introduced as systemd gained prominence as the default init system in Linux distributions. It reflects systemd's capability to manage system state and resources dynamically, leveraging D-Bus for inter-process communication and runtime configuration. While systemd itself emerged around 2010, `set-property` matured alongside features like cgroups integration, allowing for sophisticated, real-time resource governance directly from the command line. Its development underscores the shift towards more flexible and observable system management paradigms in modern Linux environments.


title: TLDR
content:
<b>Set a property for a running service</b>`systemctl set-property [unit] [property]=[value]`<br><b>Set multiple properties at once</b>`systemctl set-property [unit] [property_1=value_1 property_2=value_2 ...]`<br><b>Set a property only for the current runtime session (not persistent)</b>`systemctl set-property [unit] [property]=[value] --runtime`<br><b>Reset a property to its default value</b>`systemctl set-property [unit] [property]=`<br><b>Reset multiple properties to its default values</b>`systemctl set-property [unit] [property_1= property_2= ...]`


title: SYNOPSIS
content:
<I>bun build</I> <I>[entrypoint...]</I> <I>[options]</I><br>Example: <I>bun build src/index.ts --outfile dist/bundle.js --minify</I><br>Note: <I>bun-build</I> is invoked as a subcommand of the <I>bun</I> CLI.


title: PARAMETERS
content:
<b><I>[entrypoint...]</I></b><br>&nbsp;&nbsp;&nbsp;&nbsp;One or more input files to start the bundling process.<br><br><b>--compile</b><br>&nbsp;&nbsp;&nbsp;&nbsp;<I>(Experimental)</I> Compiles the project into a standalone executable.<br><br><b>--external <module></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Marks a module as external, preventing it from being bundled.<br><br><b>--minify</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Enables minification of the output bundle, reducing its size.<br><br><b>--outfile <path></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specifies the path for the single output bundle file.<br><br><b>--outdir <path></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specifies the directory for the output bundles and assets.<br><br><b>--target <runtime></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Sets the target runtime environment (e.g., <I>browser</I>, <I>node</I>, <I>bun</I>).<br><br><b>--format <format></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Defines the output module format (e.g., <I>esm</I>, <I>cjs</I>, <I>iife</I>).<br><br><b>--sourcemap</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Generates source maps to aid in debugging bundled code.<br><br><b>--watch</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Watches for file changes and automatically rebuilds the bundle.<br><br><b>-d, --development</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Builds for development, typically without minification.<br><br><b>-p, --production</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Builds for production, enabling optimizations like minification.<br><br><b>--define <key=value></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Replaces global identifiers with specified values during bundling.<br><br><b>--splitting</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Enables code splitting to generate multiple output chunks for better loading performance.<br><br><b>--public-path <path></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Sets the base public path for all assets in the output.<br><br><b>--asset-prefix <prefix></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Prepends a prefix to all asset URLs.<br><br><b>--jsx-factory <factory></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specifies a custom function for JSX element creation.<br><br><b>--jsx-fragment <fragment></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specifies a custom function for JSX fragment creation.<br><br>


title: DESCRIPTION
content:
<i>bun-build</i> is the lightning-fast, built-in JavaScript and TypeScript bundler, minifier, and transpiler provided by the Bun runtime. Designed for speed, it leverages the high-performance Zig language, offering significantly faster build times compared to traditional bundlers like Webpack or Rollup. It supports a wide array of features including ES modules, CommonJS, JSX, TSX, CSS, and various asset types. Developers can use <i>bun-build</i> to bundle web applications, Node.js projects, or Bun-specific projects into optimized, production-ready bundles or development-friendly outputs with features like source maps and tree-shaking. Its API and CLI are designed to be intuitive and compatible with modern web development workflows, making it a powerful tool for modern JavaScript and TypeScript development.


title: CAVEATS
content:
<i>bun-build</i> is a relatively new and rapidly evolving tool. While highly performant, its feature set and configuration options may differ from more mature bundlers like Webpack. Some advanced bundling scenarios or niche plugins might not yet be fully supported. Compatibility with all existing build tool configurations might require adaptation.


title: INTEGRATED WORKFLOW
content:
<i>bun-build</i> is part of the larger Bun ecosystem, seamlessly integrating with Bun's package manager (<I>bun install</I>) and test runner (<I>bun test</I>). This creates a unified and highly performant developer workflow for JavaScript and TypeScript projects, from dependency management to building and testing.


title: PERFORMANCE ADVANTAGE
content:
Built in Zig, <i>bun-build</i> leverages low-level optimizations to achieve significantly faster build times compared to other bundlers. This performance boost is particularly noticeable in large projects and CI/CD pipelines, where build duration can heavily impact development cycles.


title: HISTORY
content:
Bun was initially announced in 2021 by Jarred Sumner, with a focus on delivering an all-in-one JavaScript runtime, bundler, and package manager. <i>bun-build</i> emerged as a core component of this vision, designed from the ground up to offer unparalleled build speeds by being written in Zig. It aims to streamline the developer experience by integrating bundling capabilities directly into the runtime, reducing the need for separate build tool installations and configurations, thus simplifying modern JavaScript project setups. Its development has focused on performance and API compatibility with existing standards.


title: TLDR
content:
<b>Bundle an entry point to a single output file</b>`bun build [path/to/entry.ts] --outfile [path/to/output.js]`<br><b>Bundle multiple entry points to an output directory</b>`bun build [path/to/entry1.ts path/to/entry2.ts ...] --outdir [path/to/dist]`<br><b>Bundle with source maps for debugging</b>`bun build [path/to/entry.ts] --outfile [path/to/output.js] --sourcemap`<br><b>Bundle with minification for production</b>`bun build [path/to/entry.ts] --outfile [path/to/output.js] --minify`<br><b>Bundle with a specific target environment</b>`bun build [path/to/entry.ts] --outfile [path/to/output.js] --target [browser|bun|node]`<br><b>Bundle to a standalone executable</b>`bun build [path/to/entry.ts] --compile --outfile [path/to/executable]`<br><b>Watch for file changes and rebuild automatically</b>`bun build [path/to/entry.ts] --outfile [path/to/output.js] --watch`<br><b>Bundle with external dependencies not included in the output</b>`bun build [path/to/entry.ts] --outfile [path/to/output.js] --external [react react-dom]`


title: PARAMETERS
content:
<b>-f, --format <FORMAT></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specify the archive format (e.g., <i>tar</i>, <i>zip</i>, <i>7z</i>).<br><br><b>-c, --compress <ALGORITHM></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specify the compression algorithm (e.g., <i>gzip</i>, <i>bzip2</i>, <i>xz</i>, <i>zstd</i>, <i>none</i>).<br><br><b>-L, --level <LEVEL></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Set the compression level (e.g., 1-9, or specific algorithm ranges).<br><br><b>-x, --exclude <PATTERN></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Exclude files or directories matching a pattern from the bundle.<br><br><b>-v, --verbose</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Display detailed progress information during the bundling process.<br><br><b>--overwrite</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Overwrite existing output archive without prompting for confirmation.<br><br><b>--checksum <ALGORITHM></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Generate a checksum for the created archive (e.g., <i>md5</i>, <i>sha256</i>).<br><br>


title: DESCRIPTION
content:
<i>bun-c</i> is analyzed here as a <b>hypothetical</b> Linux command, as it is <i>not a standard utility</i> found in common distributions. This analysis projects <i>bun-c</i> as a tool designed for the efficient <i>bundling</i> and <i>compression</i> of multiple files or directories into a single archive. Its name suggests a potential function related to "bundling" and "compressing" or "creating" archives.<br><br>If it existed, <i>bun-c</i> would likely provide a streamlined interface for creating compressed packages, analogous to combining the functionalities of <i>tar</i> with compression utilities like <i>gzip</i> or <i>bzip2</i>, but potentially with a simpler or more specialized focus. Users might specify input files/directories, an output archive name, and various compression algorithms. Such a command would be particularly useful for packaging project assets, logs, or backups for storage and transfer, offering options for different compression levels and integrity checks. This detailed examination is based on interpreting a plausible role for a command with such a name in the Linux ecosystem.


title: CAVEATS
content:
Please note that <i>bun-c</i> is <b>not a standard Linux command</b>. This analysis is entirely based on a hypothetical interpretation of its name and a plausible function it might serve if such a command existed. Its actual functionality (if it were a custom script or a typo) would depend entirely on its specific implementation. Users should verify if any command named <i>bun-c</i> exists in their environment before attempting to use it.


title: PURPOSE OF HYPOTHETICAL <I>BUN-C</I>
content:
If it were a real utility, <i>bun-c</i> would likely aim to simplify the creation of compressed archives, potentially abstracting away the complexities of combining <i>tar</i> with various compression utilities. It would offer a unified, user-friendly interface for common archiving and compression needs.


title: HISTORY
content:
Since <i>bun-c</i> is not a standard Linux command, there is no official development or usage history. If it were a custom tool, its history would be specific to its project. This hypothetical command concept draws inspiration from the long tradition of Unix/Linux archiving and compression utilities, aiming to provide a potentially streamlined or specialized interface for these common tasks.


title: TLDR
content:
<b>Create a new project from an official template interactively</b>`bun create [template]`<br><b>Create a new project from an official template in a new directory</b>`bun create [template] [path/to/destination]`<br><b>Create a new project from a GitHub repository template</b>`bun create [https://github.com/username/repo] [path/to/destination]`<br><b>Create a new project from a local template</b>`bun create [./path/to/template] [path/to/destination]`<br><b>Create a new project, overwriting the destination directory if it exists</b>`bun create [template] [path/to/destination} --force`<br><b>Create a new project without initializing a Git repository automatically</b>`bun create [template] [path/to/destination} --no-git`<br><b>Create a new project without installing dependencies automatically</b>`bun create [template] [path/to/destination} --no-install`


title: PARAMETERS
content:
<b><i>&lt;package-dir&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Optional. The path to the package directory that you want to link globally. If this argument is omitted, <i>bun link</i> will default to linking the current working directory.<br><br>


title: DESCRIPTION
content:
<i>bun link</i> is a command provided by the <b>Bun JavaScript runtime</b>, designed to facilitate local development of packages and libraries. It works by creating a symbolic link from Bun's global package link directory to a specified local package directory. This mechanism allows other projects that depend on the linked package to resolve it to your local version, rather than fetching it from a remote registry or relying on a published version.<br><br>This functionality is crucial for developers working on multiple interdependent packages, such as in a monorepo setup, or when developing a library and testing its changes directly within a consuming application. It enables rapid iteration and testing without the need to publish new versions or manage complex local path configurations. Essentially, <i>bun link</i> provides an efficient way to simulate a globally installed package using your local, work-in-progress code.<br><br>While sharing conceptual similarities with <i>npm link</i> and <i>pnpm link</i>, <i>bun link</i> is integrated into Bun's high-performance ecosystem, leveraging its fast module resolution and file system operations.


title: CAVEATS
content:
<i>bun link</i> requires the <b>Bun runtime</b> to be installed on your system.<br>This command is primarily for local development and prototyping; it should <b>not</b> be used for managing dependencies in production environments.<br>Be mindful of potential version conflicts or unexpected behavior if multiple projects link different versions of the same package globally.<br>To remove a globally linked package, you typically use the <i>bun unlink</i> command.


title: PURPOSE OF LOCAL LINKING
content:
The primary purpose of local linking is to enable developers to iterate on changes in a package or library and immediately test those changes within a consuming application without the overhead of publishing or repeatedly installing local path dependencies. It streamlines the development workflow for interdependent projects.


title: GLOBAL LINK DIRECTORY
content:
When <i>bun link</i> is executed, it typically creates a symbolic link within Bun's internal global link directory (e.g., often located in a user's home directory under a <i>.bun</i> configuration path). This central location allows other projects managed by Bun to easily discover and use the locally linked package.


title: HISTORY
content:
The <i>bun link</i> command has been a core feature of the <b>Bun JavaScript runtime</b> since its early development stages. It was included to ensure Bun provided a complete and ergonomic developer experience, mirroring essential functionalities found in other modern JavaScript package managers. Its development reflects Bun's commitment to offering high-performance alternatives for common Node.js and npm workflows, focusing on speed and a native-like feel for package management operations.


title: TLDR
content:
<b>Link the package globally</b>`bun link`<br><b>Link a package locally to a project</b>`bun link [package_name]`<br><b>Link directly from a local path</b>`bun link [path/to/package]`<br><b>Unlink a package</b>`bun unlink [package_name]`<br><b>Unlink a global package</b>`bun unlink --global [package_name]`<br><b>Display help</b>`bun link --help`


title: SYNOPSIS
content:
<b><I>bun remove</I></b> [options] <I>&lt;packages...&gt;</I><br><b><I>bun uninstall</I></b> [options] <I>&lt;packages...&gt;</I>


title: PARAMETERS
content:
<b><I>&lt;packages...&gt;</I></b><br>&nbsp;&nbsp;&nbsp;&nbsp;One or more package names to remove. Multiple packages should be separated by spaces.<br><br><b><b>-D, --dev</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Remove the specified package(s) from <b>devDependencies</b>, which are only needed during development.<br><br><b><b>-O, --optional</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Remove the specified package(s) from <b>optionalDependencies</b>, which might not be available or needed on all platforms.<br><br><b><b>-P, --peer</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Remove the specified package(s) from <b>peerDependencies</b>, which are dependencies that the host project should provide.<br><br><b><b>-g, --global</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Remove the specified package(s) from global installation. Global packages are typically installed in a system-wide location accessible from any project.<br><br><b><b>--dry-run</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Show what would be removed without actually performing the removal operation. Useful for testing changes safely.<br><br><b><b>--silent</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Suppress all output messages from the command, showing only errors.<br><br><b><b>--help</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Display help information for the <b>bun remove</b> command, including all available options and usage examples.<br><br>


title: DESCRIPTION
content:
The command name "bun-remove" is <I>not a standard or recognized Linux command</I> or standalone executable. It is highly probable that it refers to the functionality provided by the <I>Bun JavaScript runtime's package manager</I> to remove installed project dependencies. Specifically, users typically invoke this action using the subcommands <b><I>bun remove</I></b> or <b><I>bun uninstall</I></b>. These commands are used within a Bun project directory to remove specified packages from the project's dependencies, update the <b>package.json</b> file (by removing the entry from <b>dependencies</b>, <b>devDependencies</b>, etc.), and clean up the <b>bun.lockb</b> lockfile. The primary purpose is to manage project dependencies by eliminating unneeded libraries, thereby reducing project size and improving build performance.


title: CAVEATS
content:
The term "bun-remove" itself is <I>not a valid Linux command</I> or a standalone executable. Users must ensure they have the <I>Bun runtime installed</I> on their system to use the <b>bun remove</b> or <b>bun uninstall</b> subcommands. These commands only operate within the context of a <I>Bun-managed project</I> and affect its dependencies defined in <b>package.json</b>. Removing crucial dependencies can lead to <I>application malfunctions</I> or <I>failures</I> during development or production, so caution is advised.


title: COMMON USAGE EXAMPLES
content:
To remove a single package from your project's dependencies: <b><I>bun remove lodash</I></b><br>To remove multiple packages simultaneously: <b><I>bun uninstall express react</I></b><br>To remove a development dependency: <b><I>bun remove -D eslint</I></b><br>To remove a globally installed package: <b><I>bun uninstall -g typescript</I></b>


title: REMOVE VS. UNINSTALL
content:
Within the Bun package manager, <b><I>bun remove</I></b> and <b><I>bun uninstall</I></b> are <I>aliases</I> for the exact same functionality. Both commands achieve the identical outcome: removing specified packages from your project's dependencies and updating the relevant project files.


title: HISTORY
content:
Bun was created by Jarred Sumner and first publicly released in July 2022, rapidly gaining traction as a fast, all-in-one JavaScript runtime, bundler, and package manager. The <b>bun remove</b> (and <b>bun uninstall</b>) command is an integral part of its package management suite. It was designed to offer a faster and more efficient alternative to existing Node.js package managers like npm and Yarn for removing project dependencies. Its development has focused on performance, compatibility with existing Node.js ecosystems, and providing a unified development experience.


title: TLDR
content:
<b>Remove a dependency</b>`bun remove [package_name]`<br><b>Remove multiple dependencies</b>`bun remove [package_name1 package_name2 ...]`<br><b>Remove a globally installed package</b>`bun remove [[-g|--global]] [package_name]`<br><b>Remove a dependency without updating the package.json file</b>`bun remove --no-save [package_name]`<br><b>Run the command without actually removing packages (simulate the removal)</b>`bun remove --dry-run [package_name]`


title: PARAMETERS
content:
<b><i>&lt;packages...&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;One or more package names to remove. These are the names as listed in your <code>package.json</code>.<br><br><b><b>-D</b>, <b>--dev</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Removes the specified packages from the <code>devDependencies</code> section in <code>package.json</code>.<br><br><b><b>-O</b>, <b>--optional</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Removes the specified packages from the <code>optionalDependencies</code> section in <code>package.json</code>.<br><br><b><b>-P</b>, <b>--peer</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Removes the specified packages from the <code>peerDependencies</code> section in <code>package.json</code>.<br><br><b><b>--dry-run</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Performs a simulated removal without actually modifying <code>package.json</code>, <code>bun.lockb</code>, or <code>node_modules</code>. Useful for previewing changes.<br><br><b><b>-f</b>, <b>--force</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Forces the removal of packages, potentially ignoring some checks or warnings.<br><br><b><b>-h</b>, <b>--help</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Displays help information for the <code>bun rm</code> command.<br><br>


title: DESCRIPTION
content:
<code>bun rm</code> is a fundamental command within the Bun JavaScript runtime's package manager, designed to efficiently <I>remove dependencies</I> from your project.<br><br>When executed, it updates your project's <code>package.json</code> file by removing the specified packages from the relevant dependency sections (e.g., <code>dependencies</code>, <code>devDependencies</code>, <code>optionalDependencies</code>). Concurrently, it modifies the <code>bun.lockb</code> lockfile, ensuring consistency and reproducibility across installations. This process also typically triggers a re-resolution of the dependency tree and prunes the <code>node_modules</code> directory, effectively freeing up disk space and cleaning up unused packages.<br><br>It serves as Bun's counterpart to <code>npm uninstall</code> or <code>yarn remove</code>, offering a fast and robust way to manage your project's dependency footprint, making it easier to maintain lean and optimized applications.


title: CAVEATS
content:
<code>bun rm</code> primarily operates on project-local dependencies defined in <code>package.json</code>. It does not directly manage globally installed Bun executables or modules in the same way <code>npm uninstall -g</code> does for Node.js.<br><br>The command requires the <B>Bun runtime</B> to be installed and accessible in your system's PATH.<br><br>Changes made by <code>bun rm</code> are reflected in <code>package.json</code> and <code>bun.lockb</code>. Always commit these files to version control after making dependency changes.


title: USAGE EXAMPLES
content:
To remove a single package:<br> <code><b>bun rm lodash</b></code><br><br>To remove multiple packages simultaneously:<br> <code><b>bun rm react vue</b></code><br><br>To remove a package specifically from <code>devDependencies</code>:<br> <code><b>bun rm -D webpack</b></code><br><br>To see what would be removed without actually doing it:<br> <code><b>bun rm some-package --dry-run</b></code>


title: HISTORY
content:
<code>bun rm</code> has been an integral part of the <B>Bun JavaScript runtime</B> since its early development. Bun, created by Jarred Sumner, emerged with a strong focus on <I>speed and all-in-one tooling</I> for web development. The <code>rm</code> command embodies this philosophy by providing a fast and efficient way to manage project dependencies, mirroring the functionality of established package managers like npm and Yarn but with Bun's native performance advantages. Its design ensures compatibility with existing Node.js package ecosystems while leveraging Bun's internal architecture for rapid dependency resolution and file system operations.


title: SYNOPSIS
content:
Since 'doom' itself is not a standard command, this synopsis represents a common usage pattern with a popular <i>Doom</i> source port, <i>GZDoom</i>, as an example:<br><br><code><b>gzdoom</b> [<i>options</i>] [-<b>iwad</b> <i>IWAD_file</i>] [-<b>file</b> <i>PWAD_file</i> [<i>PWAD_file2</i> ...]]</code><br><br><i>Note:</i> The exact command and its options vary significantly depending on the specific <i>Doom</i> source port installed.


title: PARAMETERS
content:
<b><b>-iwad</b> <i>&lt;file&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specifies the primary IWAD file to load (e.g., <code>doom.wad</code>, <code>doom2.wad</code>).<br><br><b><b>-file</b> <i>&lt;file1&gt;</i> [<i>&lt;file2&gt;</i> ...]</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Loads one or more custom WADs or PK3 files (PWADs) containing mods, levels, or textures.<br><br><b><b>-warp</b> <i>&lt;map&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Starts the game directly on a specified map (e.g., <code>E1M1</code>, <code>MAP01</code>).<br><br><b><b>-skill</b> <i>&lt;level&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Sets the game difficulty level (1-5).<br><br><b><b>-host</b> <i>&lt;players&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Starts a multiplayer server for the specified number of players.<br><br><b><b>-join</b> <i>&lt;address&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Joins an existing multiplayer game at the given IP address.<br><br><b><b>-nosound</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Disables all in-game sound and music.<br><br><b><b>-fullscreen</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Forces the game to start in fullscreen mode.<br><br><b><b>-windowed</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Forces the game to start in a windowed mode.<br><br><b><b>-config</b> <i>&lt;file&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Uses a specified configuration file instead of the default.<br><br><b><b>-savedir</b> <i>&lt;directory&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Sets the directory where save games and configuration files are stored.<br><br><b><b>-deh</b> <i>&lt;file&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Loads a Dehacked patch file to modify game behavior.<br><br>


title: DESCRIPTION
content:
The 'doom' command on Linux does not refer to a single, universal shell utility but rather to the act of launching a <i>Doom</i> game via a dedicated <i>source port</i> or <i>game engine</i>. Original <i>Doom</i> games require specific game data files, known as IWADs (e.g., <i>DOOM.WAD</i>, <i>DOOM2.WAD</i>), to run. On Linux, users typically install a popular <i>Doom</i> source port such as <i>GZDoom</i>, <i>PrBoom+</i>, or <i>Chocolate Doom</i> through their distribution's package manager. The actual command used will be the executable of the chosen source port (e.g., <code>gzdoom</code>, <code>prboom-plus</code>, <code>chocolate-doom</code>), which then loads the necessary WAD files to start the game. This approach allows players to enjoy the classic first-person shooter experience, often with modern enhancements provided by the source port.


title: CAVEATS
content:
The primary caveat is that a direct <code><b>doom</b></code> command is generally <i>not</i> part of standard Linux distributions. Users must first install a <i>Doom source port</i> (e.g., <i>GZDoom</i>, <i>PrBoom+</i>). Additionally, you need the original game's IWAD files, which are typically not included with the source port and must be acquired separately (e.g., from an original game copy or official re-releases). Compatibility with various mods (PWADs/PK3s) can vary between different source ports.


title: IWADS VS. PWADS
content:
An <i>IWAD</i> (Internal WAD) is the primary game data file containing levels, graphics, sounds, and other core assets of an official <i>Doom</i> game (e.g., <i>DOOM.WAD</i>, <i>DOOM2.WAD</i>). A <i>PWAD</i> (Patch WAD) or PK3/ZIP file is a custom addon created by players, containing new levels, monsters, weapons, or other modifications. PWADs require an IWAD to run and are loaded 'on top' of the base game data.


title: CHOOSING A SOURCE PORT
content:
Several <i>Doom source ports</i> are available, each with different goals. <i>Chocolate Doom</i> aims for perfect emulation of the original DOS executable. <i>PrBoom+</i> offers a balance of vanilla-like behavior with modern conveniences and demo compatibility. <i>GZDoom</i> is a highly advanced port known for its extensive modding capabilities, true 3D environments, scripting, and support for modern graphics features. The choice depends on whether you prefer a vanilla experience, competitive play, or extensive modding.


title: INSTALLATION ON LINUX
content:
Most <i>Doom source ports</i> can be installed via your Linux distribution's package manager (e.g., <code><b>sudo apt install gzdoom</b></code> on Debian/Ubuntu, <code><b>sudo dnf install gzdoom</b></code> on Fedora). After installation, you typically place your legally acquired IWAD files into a designated directory (often <code><b>~/.config/gzdoom/</b></code> or <code><b>~/.local/share/games/doom/</b></code>) or specify their path using the <code><b>-iwad</b></code> option when launching the game.


title: HISTORY
content:
The original <i>Doom</i> game, released by <i>id Software</i> in 1993, revolutionized first-person shooters. Its source code was famously released under the GNU GPL in 1997, leading to a proliferation of <i>source ports</i>. These ports are enhanced versions of the original game engine, developed by the community, allowing <i>Doom</i> to run on modern operating systems like Linux, often with improved graphics, sound, and gameplay features. This open-source development has kept <i>Doom</i> alive and thriving for decades, constantly evolving its capabilities and community contributions.


title: SEE ALSO
content:
<b>gzdoom</b>(6): A popular, advanced <i>Doom</i> source port., <b>prboom-plus</b>(6): Another widely used <i>Doom</i> source port, focusing on accuracy and competitive play., <b>chocolate-doom</b>(6): A source port aiming for vanilla <i>Doom</i> authenticity., <b>xdg-open</b>(1): Can be used to open a WAD file if a default application is set.


title: TLDR
content:
<b>Host co-op multiplayer</b>`[zandronum-server] -iwad [wad] +map [map] -host [players]`<br><b>Host deathmatch multiplayer</b>`[zandronum-server] -iwad [wad] +map [map] -host [players] -deathmatch`


title: SYNOPSIS
content:
<b>ipinfo</b> [<i>OPTIONS</i>] [<i>IP_ADDRESS</i>]<br><b>ipinfo</b> [<i>COMMAND</i>] [<i>ARGS...</i>]<br><i>(Examples: <b>ipinfo 1.1.1.1</b>, <b>ipinfo --json 8.8.8.8</b>, <b>ipinfo myip</b>)</i>


title: PARAMETERS
content:
<b><i>IP_ADDRESS</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;The IPv4 or IPv6 address to look up. If omitted, it defaults to your public IP.<br><br><b>--token <i>TOKEN</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Use a specific API token for authentication, enabling higher rate limits and access to more data.<br><br><b>--field <i>FIELD</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Display only a specific field from the lookup result (e.g., <i>country</i>, <i>org</i>, <i>city</i>).<br><br><b>--json</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Output the results in JSON format.<br><br><b>--csv</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Output results in CSV format, typically used for bulk queries.<br><br><b>--pretty</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Pretty print JSON output for better readability.<br><br><b>--version</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Show the command's version information.<br><br><b>--help</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Show help message for the command or a subcommand.<br><br>


title: DESCRIPTION
content:
The <b>ipinfo</b> command-line interface (CLI) client provides a convenient way to retrieve detailed information about IP addresses directly from your terminal. It leverages the ipinfo.io API, a widely used service for IP geolocation, Autonomous System Number (ASN) details, company information, and more.<br><br>Users can query their own public IP address or specify any IPv4 or IPv6 address to get data such as country, region, city, postal code, latitude/longitude, ISP, organization name, and ASN. The CLI supports various output formats, including plain text, JSON, and CSV, and allows filtering for specific data fields. It's particularly useful for network diagnostics, security analysis, and automating tasks requiring IP-based data.


title: CAVEATS
content:
The <b>ipinfo</b> command is not a standard Linux utility; it requires separate installation (e.g., via <i>go install</i>, package managers like <i>brew</i>, or pre-compiled binaries).<br><br>It relies entirely on the external ipinfo.io API for data, meaning network connectivity is essential. Free usage is subject to rate limits, and an API token is often required for higher usage and access to certain premium data fields.<br><br>Sending IP addresses to an external service might have privacy implications depending on the usage context. The accuracy of geolocation data can also vary.


title: SUBCOMMANDS
content:
The <b>ipinfo</b> CLI supports a variety of subcommands that extend its functionality beyond simple IP lookups. These include <b>ipinfo bulk</b> for processing lists of IP addresses, <b>ipinfo map</b> to generate a map of IP locations, <b>ipinfo myip</b> to quickly get your own public IP, <b>ipinfo summary</b> for aggregate statistics, and <b>ipinfo countries</b> for country-specific data. Each subcommand often has its own set of options and arguments.


title: API TOKEN CONFIGURATION
content:
Users can configure their API token globally using <b>ipinfo init</b> or by setting the <b>IPINFO_TOKEN</b> environment variable. This allows for consistent access to authenticated features and higher rate limits without needing to pass the <i>--token</i> flag for every command.


title: HISTORY
content:
The <b>ipinfo</b> command-line client was developed by the team behind ipinfo.io, a popular IP data API service launched around 2013. The CLI tool emerged to provide developers and system administrators with a convenient, scriptable interface to their API, simplifying IP data lookups directly from the terminal without needing to write custom API calls. Its development focuses on ease of use, performance, and integrating with the evolving features of the ipinfo.io service.


title: TLDR
content:
<b>Display details for your current IP address</b>`ipinfo myip`<br><b>Display details for a specific IP address</b>`ipinfo [ip_address]`<br><b>Display details for multiple IP addresses in bulk from a file</b>`ipinfo bulk [path/to/ips.txt]`<br><b>Display details for a CIDR or IP range</b>`ipinfo bulk [cidr_range]`<br><b>Display only specific fields from IP lookup results</b>`ipinfo [ip_address] [[-f|--field]] [hostname,country,org]`<br><b>Summarize details for a group of IP addresses</b>`ipinfo summarize [path/to/ips.txt]`<br><b>Extract IP addresses from text and highlight them</b>`ipinfo grepip [path/to/file.txt]`<br><b>Display help</b>`ipinfo [[-h|--help]]`


title: SYNOPSIS
content:
The most common command-line interaction with Jenkins is via its CLI tool:<br><br><I>java -jar jenkins-cli.jar -s <B>JENKINS_URL</B> [general-options] <B>command</B> [command-options] [arguments]</I><br><br><b>Example:</b><br><I>java -jar jenkins-cli.jar -s http://localhost:8080/ build my-job</I>


title: PARAMETERS
content:
<b><b>General Jenkins CLI Options:</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;These options are used with the <I>java -jar jenkins-cli.jar</I> invocation before specifying a Jenkins CLI command.<br><br><b><b>-s</b> <I>URL</I></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specifies the URL of the Jenkins server to connect to. This is usually mandatory.<br><br><b><b>-i</b> <I>KEYFILE</I></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Uses the specified private key file for authentication against the Jenkins server.<br><br><b><b>-auth</b> <I>USER:TOKEN</I></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Provides username and API token for authentication. The API token can be generated from the user's Jenkins profile.<br><br><b><b>-webSocket</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Connects to the Jenkins server using WebSocket protocol for communication.<br><br><b><b>-remoting</b> <I>PROTOCOL</I></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specifies the Remoting protocol version to use for communication (e.g., <I>4</I>, <I>5</I>).<br><br><b><b>help</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Displays general help for the CLI or detailed help for a specific command if followed by the command name (e.g., <I>help build</I>).<br><br><b><b>Specific Jenkins CLI Commands (Examples):</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Jenkins CLI offers numerous commands. Each command has its own specific options and arguments.<br><br><b><b>build</b> <I>JOB_NAME</I></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Triggers a build for the specified job. Can include optional parameters via <I>-p</I>.<br><br><b><b>-s</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;(For <I>build</I> command) Waits for the build to complete before returning.<br><br><b><b>-p</b> <I>NAME=VALUE</I></b><br>&nbsp;&nbsp;&nbsp;&nbsp;(For <I>build</I> command) Adds a build parameter. Can be specified multiple times for multiple parameters.<br><br><b><b>list-jobs</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Lists all available jobs on the Jenkins server.<br><br><b><b>restart</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Restarts the Jenkins server (requires appropriate permissions).<br><br><b><b>safe-restart</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Restarts Jenkins safely, waiting for current builds to finish.<br><br><b><b>who-am-i</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Shows the details of the currently authenticated user.<br><br>


title: DESCRIPTION
content:
Jenkins is a leading open-source automation server widely used to automate parts of the software development process, including building, testing, and deploying applications.<br><br>While 'jenkins' is not a direct executable command like <I>ls</I> or <I>grep</I> found in <I>/usr/bin</I>, it refers to the server application itself, typically run as a daemon process on a Linux system. Users interact with Jenkins primarily through its web-based user interface, but it also offers a powerful Command Line Interface (CLI) tool for scriptable access to Jenkins functionality. On Linux, Jenkins is commonly installed as a system service, managed using tools like <I>systemctl</I> to start, stop, or check its status.<br><br>Its core function is to facilitate continuous integration and continuous delivery (CI/CD) pipelines, enabling developers to automate various tasks and ensure code quality and rapid delivery.


title: CAVEATS
content:
The name 'jenkins' does not refer to a standalone executable command typically found in standard Linux PATH directories like <I>/usr/bin</I>. Instead, Jenkins is an application server managed as a service. Command-line interaction is primarily done via the Jenkins CLI tool (requiring <I>java</I> and <I>jenkins-cli.jar</I>) or by managing the Jenkins service with system utilities like <I>systemctl</I> (e.g., <I>systemctl start jenkins</I>). Direct execution of a command named <I>jenkins</I> is not common unless a custom script or alias is created.


title: SERVICE MANAGEMENT
content:
On systemd-based Linux systems, the Jenkins server is managed as a background service. Common commands include <I>sudo systemctl start jenkins</I>, <I>sudo systemctl stop jenkins</I>, <I>sudo systemctl restart jenkins</I>, and <I>sudo systemctl status jenkins</I> to control its lifecycle.


title: WEB UI ACCESS
content:
Jenkins' primary interface is its web application, typically accessible via <I>http://localhost:8080</I> (or a configured port and hostname) after installation. Initial setup and most configuration and job management are performed through this web interface.


title: JENKINS CLI TOOL DOWNLOAD
content:
The <I>jenkins-cli.jar</I> tool can usually be downloaded directly from your Jenkins server at <I>http://<B>JENKINS_URL</B>/jnlpJars/jenkins-cli.jar</I>. This ensures compatibility with your specific Jenkins version.


title: HISTORY
content:
Jenkins originated as a fork of the Hudson project in 2011, following a dispute with Oracle concerning the Hudson project's governance. Developed by Kohsuke Kawaguchi, who initially created Hudson, Jenkins quickly gained traction due to its strong community support, extensive plugin ecosystem, and commitment to open-source principles.<br><br>It has since become a de-facto standard for CI/CD, evolving continuously with features like Pipeline as Code, declarative pipelines, and container support, establishing itself as a robust platform for automating software delivery.


title: TLDR
content:
<b>Connect to jenkins CLI</b>`java -jar jenkins-cli.jar -s [jenkins_server_url] -auth [username]:[api_token]`<br><b>Restart jenkins</b>`java -jar jenkins-cli.jar -s [jenkins_server_url] restart`<br><b>Shutdown jenkins</b>`java -jar jenkins-cli.jar -s [jenkins_server_url] shutdown`<br><b>Display help</b>`java -jar jenkins-cli.jar -s [jenkins_server_url] help`<br><b>Display version</b>`java -jar jenkins-cli.jar -s [jenkins_server_url] version`


title: SYNOPSIS
content:
<b>kaggle competitions</b> <i>list</i> [<i>-s KEYWORD</i>] [<i>-p PAGE_NUMBER</i>] [<i>-o</i>]<br><b>kaggle competitions</b> <i>files</i> <b>-c NAME</b><br><b>kaggle competitions</b> <i>download</i> <b>-c NAME</b> [<i>-f FILENAME</i>] [<i>-p PATH</i>] [<i>-a</i>] [<i>-F</i>]<br><b>kaggle competitions</b> <i>submit</i> <b>-c NAME</b> <b>-f FILE</b> <b>-m MESSAGE</b><br><b>kaggle competitions</b> <i>submissions</i> <b>-c NAME</b> [<i>-p PAGE_NUMBER</i>]<br><b>kaggle competitions</b> <i>leaderboard</i> <b>-c NAME</b> [<i>-s KEYWORD</i>] [<i>-u USERNAME</i>]


title: PARAMETERS
content:
<b><i>list</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Lists available Kaggle competitions.<br><br><b><i>list -s KEYWORD</i>, <i>--search KEYWORD</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Searches for competitions matching the specified keyword.<br><br><b><i>list -p PAGE_NUMBER</i>, <i>--page PAGE_NUMBER</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Displays a specific page of competition results.<br><br><b><i>list -o</i>, <i>--old</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Includes older, inactive competitions in the list.<br><br><b><i>files -c NAME</i>, <i>--competition NAME</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Lists all data files associated with the specified competition.<br><br><b><i>download -c NAME</i>, <i>--competition NAME</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Downloads all data files for the specified competition.<br><br><b><i>download -f FILENAME</i>, <i>--file FILENAME</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Downloads a specific file from the competition.<br><br><b><i>download -p PATH</i>, <i>--path PATH</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specifies the local directory to download files to. Defaults to the current directory.<br><br><b><i>download -a</i>, <i>--all</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Downloads all competition files (redundant with default behavior if no -f is specified).<br><br><b><i>download -F</i>, <i>--force</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Overwrites existing files during download without prompting.<br><br><b><i>submit -c NAME</i>, <i>--competition NAME</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specifies the competition to submit to.<br><br><b><i>submit -f FILE</i>, <i>--file FILE</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specifies the path to your submission file.<br><br><b><i>submit -m MESSAGE</i>, <i>--message MESSAGE</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Provides a descriptive message for your submission.<br><br><b><i>submissions -c NAME</i>, <i>--competition NAME</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Lists your past submissions for the specified competition.<br><br><b><i>submissions -p PAGE_NUMBER</i>, <i>--page PAGE_NUMBER</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Displays a specific page of your submission history.<br><br><b><i>leaderboard -c NAME</i>, <i>--competition NAME</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Displays the current leaderboard for the specified competition.<br><br><b><i>leaderboard -s KEYWORD</i>, <i>--search KEYWORD</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Searches the leaderboard by user or team name.<br><br><b><i>leaderboard -u USERNAME</i>, <i>--user USERNAME</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Filters the leaderboard to show results for a specific username.<br><br>


title: DESCRIPTION
content:
The <b>kaggle competitions</b> command is a crucial component of the Kaggle Command Line Interface (CLI), providing a direct way to interact with Kaggle competition data and participate in competitions without leaving your terminal. It allows users to browse available competitions, inspect their details, list and download competition datasets, make submissions, track submission history, and view leaderboards. This tool streamlines the workflow for data scientists, enabling automation of common tasks and integration with scripting environments. It relies on the Kaggle API, requiring an API token for authentication, which must be configured beforehand. The command significantly enhances productivity by allowing programmatic access to competition-related tasks.


title: CAVEATS
content:
The <b>kaggle competitions</b> command requires a Kaggle API token for authentication, which must be configured in `~/.kaggle/kaggle.json`. Users must accept competition rules and terms on the Kaggle website before attempting to download data or make submissions, as this cannot be done through the CLI. Downloads of large datasets may consume significant bandwidth and time.


title: <B>AUTHENTICATION SETUP</B>
content:
To use the Kaggle CLI, you must generate an API token from your Kaggle account settings (Profile -> Account -> Create New API Token). This token is downloaded as `kaggle.json` and should be moved to `~/.kaggle/kaggle.json` on Linux/macOS or `C:\Users\<Windows-username>\.kaggle\kaggle.json` on Windows. Ensure this file has appropriate read-only permissions for security.


title: <B>COMPETITION RULES ACCEPTANCE</B>
content:
Before downloading competition data or submitting solutions, Kaggle often requires users to manually accept the competition's specific rules and terms of service. This acceptance process currently occurs only through the Kaggle website, not via the CLI. Attempting to download or submit without prior acceptance will result in an error.


title: HISTORY
content:
The Kaggle API and its corresponding CLI client were developed by Kaggle to enable programmatic interaction with the platform. The <b>kaggle competitions</b> subcommand has been a foundational part of the CLI since its initial release, evolving with the Kaggle platform to support new competition features, data types, and submission mechanisms. This continuous development has significantly enhanced the automation and scripting capabilities for data scientists participating in Kaggle competitions.


title: TLDR
content:
<b>List all competitions</b>`kaggle [[c|competitions]] list`<br><b>Download competition data</b>`kaggle [[c|competitions]] download [competition_name]`<br><b>Download specific file</b>`kaggle [[c|competitions]] download [competition_name] [[-f|--file]] [file]`<br><b>Submit files to a competition</b>`kaggle [[c|competitions]] submit [competition_name] [[-f|--file]] [path/to/file] [[-m|--message]] "[message]"`<br><b>Show or download leaderboard</b>`kaggle [[c|competitions]] leaderboard [competition_name] [--show|--download]`<br><b>View submissions</b>`kaggle [[c|competitions]] submissions [competition_name]`


title: SYNOPSIS
content:
<b>kaggle datasets</b> <<i>list</i> | <i>files</i> | <i>download</i> | <i>create</i> | <i>init</i> | <i>version</i> | <i>status</i> | <i>delete</i> | <i>update</i> | <i>metadata</i> | <i>private</i> | <i>public</i> | <i>roles</i> | <i>add-tag</i> | <i>remove-tag</i>> [<i>options</i>]


title: PARAMETERS
content:
<b><b>list</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Lists available datasets on Kaggle, with extensive options for filtering by search terms, owner, size, file type, license, tags, user, language, and sorting.<br><br><b><b>files</b> <<i>dataset-slug</i>></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Displays a list of all files contained within a specified dataset.<br><br><b><b>download</b> <<i>dataset-slug</i>></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Downloads files from a specified dataset to the local filesystem. Supports downloading specific files or all dataset content, and can skip existing files.<br><br><b><b>create</b> <i>-p</i> <<i>path</i>></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Creates a new dataset on Kaggle from files located in a local directory. This operation requires a correctly formatted <i>dataset-metadata.json</i> file within the directory for initial setup.<br><br><b><b>init</b> <i>-p</i> <<i>path</i>></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Initializes a local directory for a new dataset by generating a template <i>dataset-metadata.json</i> file, guiding the user in defining dataset properties.<br><br><b><b>version</b> <<i>dataset-slug</i>></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Retrieves and displays detailed metadata about a specific version of a dataset, including file hashes, creation date, and associated comments.<br><br><b><b>status</b> <<i>dataset-slug</i>></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Checks and reports the current upload or processing status of a dataset, useful after creating or updating a dataset.<br><br><b><b>delete</b> <<i>dataset-slug</i>></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Permanently deletes a specified dataset from Kaggle. This action is irreversible.<br><br><b><b>update</b> <i>-p</i> <<i>path</i>></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Updates an existing dataset with new files or modified metadata from a local directory, creating a new dataset version.<br><br><b><b>metadata</b> <<i>dataset-slug</i>></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Views or allows interactive editing of a dataset's metadata, such as its title, description, and tags.<br><br><b><b>private</b> <<i>dataset-slug</i>></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Changes the visibility of the specified dataset to private, restricting access to only its collaborators.<br><br><b><b>public</b> <<i>dataset-slug</i>></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Changes the visibility of the specified dataset to public, making it accessible to the entire Kaggle community.<br><br><b><b>roles</b> <<i>dataset-slug</i>></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Manages user roles and permissions for a dataset, allowing sharing and collaboration control.<br><br><b><b>add-tag</b> <<i>dataset-slug</i>> <<i>tag</i>></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Adds a specified tag to a dataset, improving its discoverability and categorization.<br><br><b><b>remove-tag</b> <<i>dataset-slug</i>> <<i>tag</i>></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Removes a specified tag from a dataset.<br><br>


title: DESCRIPTION
content:
The <b>kaggle-datasets</b> command is an essential component of the Kaggle API client, offering a powerful command-line interface for seamless interaction with datasets hosted on Kaggle.com. It empowers data scientists, machine learning practitioners, and researchers to programmatically list, search, download, create, update, and delete datasets, as well as manage their associated metadata and permissions. This tool significantly streamlines data workflows by enabling the automation of data acquisition, publication, and version control directly from the terminal or scripts. It integrates effortlessly into existing data pipelines and development environments. Users can explore dataset files, monitor upload status, and control dataset visibility (public or private) without needing to access the Kaggle website directly, thereby enhancing productivity for a wide range of data-centric projects. The command provides granular control over dataset lifecycle management, from initial creation to deprecation.


title: CAVEATS
content:
Using <b>kaggle-datasets</b> necessitates prior configuration of Kaggle API credentials, typically through a <i>kaggle.json</i> file located in the <i>~/.kaggle/</i> directory. Users must adhere to the dataset slug format (e.g., <i>ownerUsername/dataset-name</i>) when referencing specific datasets. Operations involving large datasets, such as downloads or uploads, can be time-consuming and bandwidth-intensive. For dataset creation and updates, the accuracy and proper formatting of the <i>dataset-metadata.json</i> file are critical for successful execution.


title: AUTHENTICATION
content:
The <b>kaggle-datasets</b> command, like all Kaggle API tools, requires user authentication. This is typically achieved by placing a <i>kaggle.json</i> file, which contains your Kaggle username and API key, in the <i>~/.kaggle/</i> directory. This file can be securely downloaded from your Kaggle account settings page.


title: DATASET SLUG FORMAT
content:
Many <b>kaggle-datasets</b> subcommands require a 'dataset slug' to uniquely identify the target dataset. This slug follows a specific format: <i>ownerUsername/dataset-name</i>. For instance, 'kaggle/titanic' refers to the well-known Titanic dataset maintained by Kaggle itself.


title: HISTORY
content:
The Kaggle API and its command-line client were developed to provide programmatic access to Kaggle's platform, extending capabilities beyond the web interface. This innovation enabled significant automation for data science workflows, simplifying the management of datasets, competition submissions, and kernel interactions directly from scripts or CI/CD pipelines. The <b>kaggle-datasets</b> command specifically evolved to support the entire lifecycle of data, from publishing new resources and maintaining versions to facilitating community sharing, thereby becoming a cornerstone for collaborative data projects on the platform.


title: TLDR
content:
<b>List all datasets owned by a user or organization</b>`kaggle [[d|datasets]] list --user [username]`<br><b>Search dataset by name</b>`kaggle [[d|datasets]] list [[-s|--search]] "[dataset_name]"`<br><b>Download a dataset</b>`kaggle [[d|datasets]] download "[dataset_name]"`<br><b>Create a public dataset</b>`kaggle [[d|datasets]] create [[-p|--path]] [path/to/dataset] [[-u|--public]]`<br><b>Download metadata of dataset</b>`kaggle [[d|datasets]] metadata [dataset_name]`<br><b>Initialize metadata for dataset</b>`kaggle [[d|datasets]] init [[-p|--path]] [path/to/dataset]`<br><b>Delete a dataset</b>`kaggle [[d|datasets]] delete [dataset_name]`


title: TLDR
content:
<b>Create a new note in your $EDITOR</b>`nb [[a|add]] "[note_title]"`<br><b>Edit a note in your $EDITOR</b>`nb [[e|edit]] [note_id]`<br><b>List all notes in the current notebook</b>`nb list`<br><b>Add a todo</b>`nb [[to|todos]] [[a|add]] [title]`<br><b>Import a file</b>`nb import ([path/to/file|url])`<br><b>Search for notes containing a keyword</b>`nb [[q|search]] "[keyword]"`<br><b>Sync notes via Git</b>`nb sync`<br><b>Display help</b>`nb help`


title: PARAMETERS
content:
<b>--production</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Install production dependencies only, skipping <i>devDependencies</i>. This is useful for deployment environments where development tools are not needed.<br><br><b>--prefix <path></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Run this command in the context of the specified directory rather than the current working directory. All file system operations will be relative to this path.<br><br><b>--ignore-scripts</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Do not run any <i>preinstall</i>, <i>install</i>, <i>postinstall</i>, <i>pretest</i>, or <i>posttest</i> scripts. This can be useful for security or debugging issues related to script execution.<br><br><b>--loglevel <level></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Sets the level of logging output. Common levels include <i>silent</i>, <i>error</i>, <i>warn</i>, <i>http</i>, <i>info</i> (default), <i>verbose</i>, and <i>silly</i>.<br><br><b>--force</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Forces <i>npm install</i> to fetch remote resources even if a local copy exists and to overwrite existing files. For <i>npm test</i>, it doesn't have a direct effect unless combined with other actions.<br><br><b>--dry-run</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Shows what would be done without actually making any changes to the file system or executing scripts. Useful for previewing changes.<br><br><b>--workspace <workspace_name>, -w <workspace_name></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Runs the command in the context of a specific workspace, identified by its name. Requires the project to be set up with npm workspaces.<br><br><b>--workspaces, -ws</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Runs the command in the context of all configured workspaces. Often used to install dependencies or run tests across an entire monorepo.<br><br>


title: DESCRIPTION
content:
<i>npm install-test</i> is a convenience command that streamlines the common workflow of setting up a project's dependencies and then executing its test suite. It first performs a clean installation of all project dependencies, including any specified <i>package-spec</i> arguments, much like <i>npm install</i>. After a successful installation, it proceeds to run the test scripts defined in the project's <i>package.json</i> file, mirroring the behavior of <i>npm test</i>.<br><br>This command is particularly useful in continuous integration (CI) environments, local development for quick verification, or after pulling changes from a version control system, ensuring that the project's state is valid and all necessary components are in place before validating functionality through tests. It provides a single point of entry to perform both crucial steps sequentially.


title: CAVEATS
content:
The command requires a valid <i>package.json</i> file in the current or specified directory, with defined dependencies and a 'test' script under the 'scripts' section. If either the installation or the test phase fails, the command will exit with a non-zero status code, indicating an error. While convenient, for complex scenarios or specific control over each phase, executing <i>npm install</i> followed by <i>npm test</i> separately might offer more flexibility.


title: EXIT STATUS
content:
The command exits with code 0 on success. A non-zero exit code indicates that either the dependency installation failed or one or more tests did not pass. This makes it suitable for use in shell scripts and automated build processes to determine the success or failure of a project's setup and validation.


title: CONFIGURATION
content:
Like other npm commands, <i>npm install-test</i> respects various configuration settings found in <i>.npmrc</i> files, environment variables, or command-line flags. This includes registry settings, proxy configurations, log levels, and other behaviors that influence how dependencies are fetched and how scripts are executed.


title: HISTORY
content:
The <i>npm install-test</i> command was introduced as a convenience subcommand to address a common development and CI/CD pattern. Prior to its existence, users would typically execute <i>npm install && npm test</i> as two separate commands. Its inclusion in npm reflects an ongoing effort to simplify frequently performed operations and improve developer experience by providing more semantic, single-command solutions for common workflows.


title: TLDR
content:
<b>Install all dependencies and then run tests</b>`npm install-test`<br><b>Install a specific package and then run tests</b>`npm install-test [package_name]`<br><b>Install a package and save it as a dependency before running tests</b>`npm install-test [package_name] [[-S|--save]]`<br><b>Install dependencies globally and then run tests</b>`npm install-test [[-g|--global]]`


title: SYNOPSIS
content:
Since "npm-it" is typically a user-defined alias or script, its exact syntax can vary. However, it commonly accepts the same options and arguments as the underlying `npm install` command it invokes.<br><b><I>npm-it</I></b> [<I>npm-install-options</I>]


title: PARAMETERS
content:
<b><b>-g</b>, <b>--global</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Installs the package globally.<br><br><b><b>--save-dev</b>, <b>-D</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Installs the package as a devDependency.<br><br><b><b>--save-peer</b>, <b>-P</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Installs the package as a peerDependency.<br><br><b><b>--save-optional</b>, <b>-O</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Installs the package as an optionalDependency.<br><br><b><b>--no-save</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Prevents saving the installed package to dependencies.<br><br><b><b>--prefix &lt;path&gt;</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Install the specified packages in a custom location.<br><br><b><b>--force</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Forces `npm install` to fetch remote resources even if a local copy exists, potentially overwriting existing files.<br><br><b><b>--dry-run</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Simulates the installation without actually installing anything.<br><br><b><b>--legacy-peer-deps</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Allows older peer dependency resolutions, useful for compatibility.<br><br>


title: DESCRIPTION
content:
The term "npm-it" typically refers to a user-defined shell alias or script, rather than a standalone standard command. It originated from the need for a quicker, often cleaner, way to install Node.js packages using `npm install`. Developers frequently define `npm-it` to encapsulate common installation workflows. The most prevalent implementation involves removing the existing `node_modules` directory and `package-lock.json` (or `npm-shrinkwrap.json`) before running `npm install`. This ensures a fresh installation, resolving potential dependency conflicts or cache issues. Other simpler definitions might just be a direct alias for `npm install`. Its purpose is to streamline the development process by providing a memorable and convenient command for package management, avoiding repetitive typing or complex command sequences.


title: CAVEATS
content:
<b>Not a Standard Command</b>: "npm-it" is not part of the official npm CLI or a standard Linux distribution. Its availability and behavior depend entirely on how a user or system administrator has defined it.<br><b>Variable Behavior</b>: The exact actions performed by `npm-it` can differ significantly between users. One user might define it for a clean install (`rm -rf node_modules && npm install`), while another might use it as a simple alias for `npm install`.<br><b>Potential for Data Loss</b>: If defined to remove `node_modules` and `package-lock.json`, misuse or misunderstanding could lead to unintended deletion of files, though generally these can be recreated.<br><b>Debugging Challenges</b>: Because it's a wrapper, debugging issues might require understanding the underlying `npm install` command and the specific script/alias definition.


title: COMMON IMPLEMENTATIONS
content:
While its definition varies, common ways users define `npm-it` include:<br><b>Clean Install:</b> `alias npm-it='rm -rf node_modules && rm -f package-lock.json && npm install'`<br>This ensures all dependencies are re-fetched and re-linked from scratch.<br><b>Simple Install:</b> `alias npm-it='npm install'`<br>A direct shortcut, often used when `ni` (npm install) is already taken or for muscle memory.<br><b>Force Install:</b> `alias npm-it='npm install --force'`<br>Forcing installations, potentially ignoring warnings and existing files.<br>Users typically add these aliases to their shell configuration files (e.g., `~/.bashrc`, `~/.zshrc`, `~/.config/fish/config.fish`).


title: HISTORY
content:
The "npm-it" pattern emerged organically within the Node.js development community as developers sought to optimize their workflow. As `node_modules` directories grew larger and `npm install` sometimes left residual issues or cache problems, the need for a "clean slate" installation became common. Instead of repeatedly typing `rm -rf node_modules && npm install`, users began creating aliases or simple shell scripts to encapsulate this logic under a memorable name like "npm-it" or "ni". This practice became widespread, particularly among developers using `bash` or `zsh`, highlighting a community-driven approach to improving developer ergonomics within the npm ecosystem.


title: PARAMETERS
content:
<b><b>-f</b>, <b>--format</b> <I>FORMAT</I></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specifies the format for the exported dependencies. <br>Common formats include <i>requirements.txt</i> and <i>pip-compile</i>.<br><br><b><b>-o</b>, <b>--output</b> <I>OUTPUT</I></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Defines the path and filename for the exported output.<br>If omitted, the output is printed to <i>stdout</i>.<br><br><b><b>--dev</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Includes development dependencies in the exported output.<br>By default, only production dependencies are exported.<br><br><b><b>--without-hashes</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Omits the package hashes from the exported file.<br>This can be useful for environments where hashes are not supported<br>or when they cause issues (e.g., older <i>pip</i> versions).<br><br><b><b>--extras</b> <I>EXTRAS</I></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Exports specific dependency 'extras' defined in <i>pyproject.toml</i>.<br>Can be specified multiple times for multiple extras.<br><br><b><b>--all-extras</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Includes all defined 'extras' in the exported dependency list.<br><br><b><b>--groups</b> <I>GROUPS</I></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specifies one or more dependency groups to explicitly include in the export.<br>Can be used multiple times.<br><br><b><b>--only</b> <I>ONLY</I></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Exclusively exports dependencies from the specified groups,<br>ignoring all other groups (including main and dev if not specified).<br><br><b><b>--without</b> <I>WITHOUT</I></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Excludes one or more dependency groups from the export.<br><br><b><b>--with</b> <I>WITH</I></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Explicitly includes one or more dependency groups in the export.<br>Useful when combined with <b>--only</b> to specify inclusions.<br><br><b><b>--without-reference</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Does not include a comment referencing the original Poetry project<br>at the top of the exported file.<br><br>


title: DESCRIPTION
content:
The <b>poetry export</b> command is a crucial tool within the <br><i>Poetry</i> dependency manager, designed to bridge the gap between <br>Poetry's sophisticated dependency resolution and traditional <br>Python package management workflows. It takes the dependencies <br>defined in your <i>pyproject.toml</i> file and precisely pinned <br>in your <i>poetry.lock</i> file, then generates a list of these <br>dependencies in various formats suitable for other tools.<br><br>The primary use case is to create a <i>requirements.txt</i> file, <br>which is widely recognized by <i>pip</i> and other deployment systems.<br>This allows projects managed by Poetry to be easily deployed to <br>environments that might not have Poetry installed, such as CI/CD <br>pipelines, Docker containers, or production servers. <br><b>poetry export</b> ensures reproducibility by always using the <br>exact versions specified in the <i>poetry.lock</i> file.<br><br>It supports exporting development dependencies, excluding <br>package hashes for simpler environments, and handling <br>project extras. This flexibility makes it indispensable for <br>maintaining a clean separation of concerns between development <br>and deployment dependency sets.


title: CAVEATS
content:
Using <b>poetry export</b> requires an existing <i>pyproject.toml</i> <br>file with defined dependencies and a corresponding <i>poetry.lock</i> <br>file, which must be up-to-date. If the <i>poetry.lock</i> file is <br>missing or outdated, Poetry may prompt to run <b>poetry install</b> <br>first or resolve dependencies implicitly. The command strictly <br>relies on the lock file for exact versions, ensuring reproducibility.<br>It only handles Python package dependencies and does not manage <br>system-level dependencies or non-Python requirements.


title: USAGE EXAMPLES
content:
<b>Export basic requirements:</b><br><i>poetry export -o requirements.txt</i><br><br><b>Export with development dependencies:</b><br><i>poetry export --dev -o dev-requirements.txt</i><br><br><b>Export without package hashes:</b><br><i>poetry export --without-hashes -o no-hash-requirements.txt</i><br><br><b>Export specific groups (e.g., 'main' and 'test'):</b><br><i>poetry export --groups main --groups test -o requirements-with-tests.txt</i><br><br><b>Export only specific groups (e.g., 'main'):</b><br><i>poetry export --only main -o production-only.txt</i><br>


title: HISTORY
content:
The <b>poetry export</b> command has been a fundamental feature of <br>the <i>Poetry</i> dependency manager since its early development by <br>Sébastien Eustace. Its inception was driven by the need to integrate <br>Poetry-managed projects into traditional Python environments <br>that primarily rely on <i>pip</i> and <i>requirements.txt</i> files.<br><br>Over time, it has evolved alongside Poetry itself, gaining <br>new options for fine-grained control over exported dependencies, <br>such as explicit handling of development dependencies, dependency <br>groups, and the inclusion/exclusion of package hashes. This <br>continuous refinement ensures that <b>poetry export</b> remains <br>a robust and flexible tool for various deployment scenarios.


title: TLDR
content:
<b>Export dependencies to a requirements.txt file</b>`poetry export [[-o|--output]] [requirements.txt]`<br><b>Export dependencies including development dependencies</b>`poetry export [[-o|--output]] [requirements-dev.txt] --dev`<br><b>Export dependencies without hashes</b>`poetry export [[-o|--output]] [requirements.txt] --without-hashes`<br><b>Export dependencies for a specific format</b>`poetry export [[-o|--output]] [requirements.txt] [[-f|--format]] [requirements.txt]`<br><b>Export only specific dependency groups</b>`poetry export [[-o|--output]] [requirements.txt] --only [main]`<br><b>Display help</b>`poetry export [[-h|--help]]`


title: TLDR
content:
<b>Create a pyproject.toml file interactively</b>`poetry init`<br><b>Create a pyproject.toml file with prefilled values</b>`poetry init --name [package_name] --author "[author_name <email@example.com>]"`<br><b>Create a pyproject.toml file without interaction (using defaults)</b>`poetry init [[-n|--no-interaction]]`<br><b>Create a pyproject.toml file and add a dependency</b>`poetry init --dependency [package_name]`<br><b>Create a pyproject.toml file and add a development dependency</b>`poetry init --dev-dependency [package_name]`<br><b>Display help</b>`poetry init [[-h|--help]]`


title: PARAMETERS
content:
<b><b>&lt;package-spec&gt;</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;An optional argument specifying the package to pack. This can be a folder path, a tarball file, a package name (<i>@scope/name</i>), a name and version (<i>name@version</i>), or a git URL. If omitted, <b>npm pack</b> will pack the package in the current working directory.<br><br><b><b>--dry-run</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Performs all actions without actually creating the tarball. It shows which files would be included in the package without writing the <i>.tgz</i> file to disk. Useful for verification.<br><br><b><b>--json</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Outputs data about the created tarball(s) as a JSON array to <i>stdout</i>. This is useful for programmatic consumption, providing details like the filename, size, and shasum of the generated archive.<br><br><b><b>--pack-destination &lt;dir&gt;</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specifies the directory where the generated tarball(s) should be saved. By default, tarballs are saved to the current working directory.<br><br>


title: DESCRIPTION
content:
The <b>npm pack</b> command creates a gzipped tarball (<i>.tgz</i>) of the current or specified package. This tarball contains all the files that would be included if the package were published to the npm registry, respecting the <i>files</i> field in <i>package.json</i> and <i>.npmignore</i> rules (which work similarly to <i>.gitignore</i>).<br><br>It's primarily used for testing a package locally before publishing it, sharing a package with others without pushing it to a registry, or for creating offline installations. When run in a package directory without arguments, it packs the current directory. If a package specifier is provided, it fetches and packs that package from the registry. Internally, <b>npm publish</b> calls <b>npm pack</b> to generate the tarball before uploading it.<br><br>The resulting <i>.tgz</i> file will be placed in the current working directory by default, but this can be changed using the <i>--pack-destination</i> option. This command is a crucial tool for developers to inspect and verify the publishable artifact.


title: CAVEATS
content:
When packing a local directory, <b>npm pack</b> runs the <i>prepack</i> script hook and does <i>not</i> run the <i>prepublish</i> script (which has been largely superseded by <i>prepare</i> and <i>prepack</i> in modern npm). Files ignored by <i>.npmignore</i> (or <i>.gitignore</i> if no <i>.npmignore</i> exists) and those not explicitly included via the <i>files</i> array in <i>package.json</i> will be excluded from the tarball, which is critical for minimizing package size. Be mindful of large files or directories that could inadvertently be included.


title: SCRIPT HOOKS
content:
<b>npm pack</b> specifically triggers the <i>prepack</i> and <i>postpack</i> lifecycle scripts defined in your <i>package.json</i>. The <i>prepack</i> script runs before the tarball is created, allowing you to perform build steps or other preparations. The <i>postpack</i> script runs after the tarball has been successfully created. This provides hooks for automating tasks related to the packing process.


title: FILE INCLUSION/EXCLUSION
content:
The contents of the generated tarball are determined by several factors:<br><i>1.</i> The <i>files</i> array in <i>package.json</i> explicitly lists files/directories to include.<br><i>2.</i> A <i>.npmignore</i> file (if present) specifies patterns of files/directories to exclude.<br><i>3.</i> If no <i>.npmignore</i> exists, <i>.gitignore</i> is used instead, but only for files not explicitly listed in <i>files</i>.<br><i>4.</i> Certain common files are always excluded (e.g., <i>.git/</i>, <i>node_modules/</i>, <i>npm-debug.log</i>, etc.) unless explicitly included by the <i>files</i> array.<br>Understanding these rules is crucial for creating correctly sized and structured packages.


title: HISTORY
content:
The <b>npm pack</b> command has been a fundamental part of the npm CLI since its early days, serving as the core mechanism for bundling package files into a distributable tarball. Its evolution is closely tied to the publishing workflow. Notably, the behavior surrounding script hooks (like <i>prepublish</i>, <i>prepare</i>, and <i>prepack</i>) has been refined over npm versions to provide clearer semantics for when scripts run during different lifecycle stages, with <i>prepack</i> specifically designed for the packing operation.


title: SYNOPSIS
content:
<b>oauth2c</b> [<i>GLOBAL_OPTIONS</i>] <i>&lt;command&gt;</i> [<i>COMMAND_OPTIONS</i>] [<i>ARGUMENTS</i>]<br><b>oauth2c auth-code</b> --client-id <i>&lt;ID&gt;</i> --client-secret <i>&lt;SECRET&gt;</i> --redirect-uri <i>&lt;URI&gt;</i> --scope <i>&lt;SCOPES&gt;</i> --auth-url <i>&lt;URL&gt;</i> --token-url <i>&lt;URL&gt;</i><br><b>oauth2c client-cred</b> --client-id <i>&lt;ID&gt;</i> --client-secret <i>&lt;SECRET&gt;</i> --scope <i>&lt;SCOPES&gt;</i> --token-url <i>&lt;URL&gt;</i><br><b>oauth2c refresh</b> --client-id <i>&lt;ID&gt;</i> --client-secret <i>&lt;SECRET&gt;</i> --refresh-token <i>&lt;TOKEN&gt;</i> --token-url <i>&lt;URL&gt;</i><br><b>oauth2c introspect</b> --token <i>&lt;TOKEN&gt;</i> --client-id <i>&lt;ID&gt;</i> --client-secret <i>&lt;SECRET&gt;</i> --introspect-url <i>&lt;URL&gt;</i><br><b>oauth2c help</b> <i>&lt;command&gt;</i>


title: PARAMETERS
content:
<b><b>--client-id</b> <i>&lt;ID&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specifies the <i>OAuth2 client ID</i> for the application.<br><br><b><b>--client-secret</b> <i>&lt;SECRET&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Provides the <i>OAuth2 client secret</i>. Use with caution for security.<br><br><b><b>--scope</b> <i>&lt;SCOPES&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;A <i>space-separated list of scopes</i> (permissions) requested from the authorization server.<br><br><b><b>--redirect-uri</b> <i>&lt;URI&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;The <i>callback URI</i> where the authorization server redirects the user after authentication. Required for authorization code flow.<br><br><b><b>--auth-url</b> <i>&lt;URL&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;The <i>authorization endpoint URL</i> of the OAuth2 provider.<br><br><b><b>--token-url</b> <i>&lt;URL&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;The <i>token endpoint URL</i> of the OAuth2 provider.<br><br><b><b>--resource-url</b> <i>&lt;URL&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;An optional URL to access a <i>protected resource</i> after obtaining a token.<br><br><b><b>--code</b> <i>&lt;CODE&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;The <i>authorization code</i> received from the authorization server (used by `auth-code` command internally or manually).<br><br><b><b>--refresh-token</b> <i>&lt;TOKEN&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;The <i>refresh token</i> used to obtain new access tokens without re-authentication.<br><br><b><b>--grant-type</b> <i>&lt;TYPE&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Explicitly specifies the <i>OAuth2 grant type</i> (e.g., `authorization_code`, `client_credentials`, `refresh_token`). May be implicit via commands.<br><br><b><b>--verbose</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Enables <i>verbose output</i>, showing more details about the request and response process.<br><br><b><b>--json</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Outputs results in <i>JSON format</i>, suitable for scripting and parsing.<br><br><b><b>--output</b> <i>&lt;FORMAT&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specifies the <i>output format</i>, e.g., `json`, `text`, `yaml`.<br><br><b><b>--help</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Displays <i>help information</i> for the command or a specific subcommand.<br><br>


title: DESCRIPTION
content:
`oauth2c` is a versatile <i>command-line interface (CLI) tool</i> designed to interact with <b>OAuth2 providers</b>. It simplifies the process of obtaining, refreshing, and managing access tokens, which are crucial for authenticating and authorizing access to protected resources. This utility is invaluable for developers, testers, and system administrators who need to integrate with OAuth2-secured APIs, test authentication flows, or automate token acquisition in scripts. <br><br>It typically supports various <b>OAuth2 grant types</b>, such as the Authorization Code Grant, Client Credentials Grant, and Refresh Token Grant, allowing users to simulate different client behaviors. By providing parameters like client ID, client secret, scopes, and redirect URIs, `oauth2c` streamlines complex OAuth2 handshakes, making it easier to debug issues and quickly obtain valid tokens without building a full client application. Its output can often be configured for human readability or machine-parseable formats like JSON, facilitating integration into automated workflows.


title: CAVEATS
content:
This command, `oauth2c`, is not a standard utility found in most Linux distributions by default. Its availability and exact functionality depend on its specific implementation (e.g., a Go-based client). Users should be aware of the following: <br><br>*   <b>Installation Required</b>: It typically needs to be installed separately, often compiled from source or obtained as a pre-built binary.<br>*   <b>Security Risks</b>: Passing <i>sensitive information</i> like client secrets or tokens directly on the command line can expose them in shell history or process listings. Consider using environment variables, configuration files, or interactive prompts for better security practices.<br>*   <b>Implementation Variations</b>: Different versions or forks of `oauth2c` might have varying options, subcommands, or behaviors, requiring users to consult the specific documentation for their version.<br>*   <b>Network Dependency</b>: Requires an active internet connection to communicate with OAuth2 providers.


title: USAGE EXAMPLES
content:
<i>Obtain an Authorization Code Token</i>:<br><code><b>oauth2c auth-code</b> --client-id "my_app_id" --client-secret "my_app_secret" --redirect-uri "http://localhost:8080/callback" --scope "profile email" --auth-url "https://provider.com/oauth/authorize" --token-url "https://provider.com/oauth/token"</code><br>This command would typically open a browser for user consent and then exchange the received code for tokens.<br><br><i>Obtain a Client Credentials Token</i>:<br><code><b>oauth2c client-cred</b> --client-id "service_app" --client-secret "service_secret" --scope "api_access" --token-url "https://provider.com/oauth/token" --json</code><br>This directly requests an access token using only client credentials, outputting the result in JSON.<br><br><i>Refresh an Access Token</i>:<br><code><b>oauth2c refresh</b> --client-id "my_app_id" --client-secret "my_app_secret" --refresh-token "previous_refresh_token" --token-url "https://provider.com/oauth/token"</code><br>Uses a stored refresh token to get a new access token, preventing repeated user logins.


title: TOKEN MANAGEMENT BEST PRACTICES
content:
For production environments or sensitive applications, avoid storing tokens directly in scripts or shell history. Consider using environment variables, secure credential stores, or interactive prompts that prevent sensitive data from being logged. Implement proper error handling and refresh token rotation strategies for robust applications.


title: HISTORY
content:
The concept behind `oauth2c` emerged with the increasing adoption of the <b>OAuth2 framework</b> for delegated authorization across web and mobile applications. As OAuth2 gained prominence, developers required simple, scriptable tools to test their integrations, obtain tokens quickly for development purposes, and automate tasks involving secure API access. <br><br>While no single, universally recognized `oauth2c` standard exists, various implementations have been developed, often in languages like Go (hence `oauth2c` being a common naming convention for Go-based clients) or Python. These tools filled a crucial gap between complex SDKs and raw HTTP clients like `curl`, offering a more structured and OAuth2-aware command-line interface. Their development reflects a broader trend towards making authentication and authorization workflows more accessible and manageable for developers directly from the terminal.


title: SYNOPSIS
content:
bun create <b>&lt;template-name | user/repo[#branch]&gt;</b> [<b>&lt;project-directory&gt;</b>] [<i>options</i>]<br><br><i>Examples:</i><br><br><code>bun create react my-app</code><br><code>bun create nextjs my-next-app</code><br><code>bun create honojs my-api</code><br><code>bun create github-user/my-template#main my-custom-app</code>


title: PARAMETERS
content:
<b><b>&lt;template-name | user/repo[#branch]&gt;</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specifies the source for the new project. This can be the <i>name of a predefined template</i> (e.g., <code>react</code>, <code>nextjs</code>, <code>astro</code>) or a <i>Git repository URL</i> in the format <code>user/repo[#branch]</code>. Bun fetches the template from this source.<br><br><b><b>[&lt;project-directory&gt;]</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;The optional name of the directory where the new project will be created. If omitted, Bun often defaults to the template name or prompts for one. If the directory already exists, <code>bun create</code> may exit or prompt for confirmation to overwrite (unless <code>--force</code> is used).<br><br>


title: DESCRIPTION
content:
bun-create is an integral subcommand of the <b>Bun JavaScript runtime</b>, engineered for the rapid scaffolding of new projects. It significantly streamlines the project initialization process by enabling users to either select from a curated list of predefined templates or specify a custom Git repository. This command intelligently handles the entire project setup, which typically includes cloning the template repository, installing necessary dependencies using Bun's ultra-fast package manager, and, if defined by the template, executing initial setup scripts. It serves as an indispensable utility for developers aiming to kickstart their Bun, React, Next.js, Astro, or other web development projects with minimal boilerplate. By promoting consistency and drastically reducing manual setup time, bun-create simplifies project creation across diverse frameworks, solidifying its role as a premier tool for modern JavaScript and TypeScript development workflows.


title: CAVEATS
content:
<ul><li><b>Network Dependency:</b> <code>bun create</code> requires an active internet connection to fetch templates, whether they are predefined or custom Git repositories.</li><li><b>Template Specificity:</b> The behavior and prompts during project creation can vary significantly based on the chosen template. Some templates may ask for additional configurations (e.g., TypeScript, ESLint setup).</li><li><b>Existing Directory:</b> If the specified <code>project-directory</code> already exists and is not empty, <code>bun create</code> will typically error out unless the global <code><b>--force</b></code> option is used to explicitly overwrite the contents.</li><li><b>Bun Installation:</b> The Bun runtime must be installed and accessible in the system's PATH for this command to function.</li></ul>


title: <B>POPULAR TEMPLATES</B>
content:
Bun supports a growing list of official and community-contributed templates. Some commonly used ones include <code>react</code> (for Vite/React), <code>nextjs</code>, <code>astro</code>, <code>hono</code>, <code>svelte</code>, <code>express</code>, and <code>elysiajs</code>. These templates offer pre-configured setups for various application types.


title: <B>CUSTOM TEMPLATE USAGE</B>
content:
Beyond predefined templates, <code>bun create</code> allows developers to bootstrap projects from any Git repository. By specifying a <code>user/repo</code> path (e.g., <code>my-org/my-starter-template</code>), Bun will clone the repository. You can also specify a specific branch using <code>#branch-name</code> (e.g., <code>my-org/my-template#dev</code>). This provides immense flexibility for organizations to maintain their own starter kits.


title: HISTORY
content:
The <code>bun create</code> command has been a fundamental component of the Bun CLI since its early public releases (circa 2022). Its design ethos closely mirrors Bun's overall focus on speed and developer experience, providing a modern alternative to traditional JavaScript project scaffolding tools. It continuously evolves with the Bun runtime, adapting to new web standards and popular frameworks to ensure a smooth and efficient project setup process.


title: SYNOPSIS
content:
<b>poetry init</b> [<i>--dependency</i> <dependency>] [<i>--dev-dependency</i> <dev-dependency>] [<i>-l | --license</i> <license>] [<i>-n | --no-interaction</i>] [<i>--directory</i> <directory>] [<i>-h | --help</i>] [<i>-q | --quiet</i>] [<i>-v | -vv | -vvv | --verbose</i>] [<i>-V | --version</i>] [<i>--ansi</i>] [<i>--no-ansi</i>]


title: PARAMETERS
content:
<b><i>--dependency</i> <dependency></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Adds a package dependency to the project. Can be specified multiple times. Format: <i>package_name[:version_constraint]</i> (e.g., <i>requests</i> or <i>requests:^2.25</i>).<br><br><b><i>--dev-dependency</i> <dev-dependency></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Adds a development dependency to the project. Can be specified multiple times. Format: <i>package_name[:version_constraint]</i>.<br><br><b><i>-l, --license</i> <license></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Sets the project's license. Common choices include <i>MIT</i>, <i>Apache-2.0</i>, <i>GPL-3.0</i>.<br><br><b><i>-n, --no-interaction</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Runs the command non-interactively, using default values for prompts that are not specified by other options.<br><br><b><i>--directory</i> <directory></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specifies the directory where the project should be initialized and the <i>pyproject.toml</i> file created. Defaults to the current working directory.<br><br><b><i>-h, --help</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Displays help for the <b>init</b> command.<br><br><b><i>-q, --quiet</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Do not output any message, suppressing all command output.<br><br><b><i>-v | -vv | -vvv, --verbose</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Increases the verbosity of messages. <i>-v</i> for normal output, <i>-vv</i> for more verbose output, <i>-vvv</i> for debug output.<br><br><b><i>-V, --version</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Displays the Poetry application version.<br><br><b><i>--ansi</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Forces ANSI output, even if not detected by the terminal.<br><br><b><i>--no-ansi</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Disables ANSI output.<br><br>


title: DESCRIPTION
content:
The <b>poetry-init</b> command is used to set up a new Python project managed by Poetry. When executed, it interactively prompts the user for essential project information such as the package name, version, description, author, and license. Based on this input, it generates a <i>pyproject.toml</i> file in the current directory. This file is the heart of a Poetry project, defining its metadata, dependencies, and build system.<br><br>While it can be run interactively, <b>poetry-init</b> also supports a non-interactive mode using the <i>--no-interaction</i> (<i>-n</i>) flag, allowing for automated project setup by providing all necessary details via command-line options. Unlike <b>poetry new</b>, which creates a new project directory and a basic file structure, <b>poetry-init</b> only focuses on creating or updating the <i>pyproject.toml</i> file in an existing directory, making it suitable for converting existing projects to Poetry or initializing a project in a pre-made directory structure.


title: CAVEATS
content:
<b>poetry-init</b> requires Poetry to be installed on your system. It is best used in an empty directory or at the root of an existing Python project that you wish to convert to Poetry management. Unlike <b>poetry new</b>, it does not create any source files or a predefined project structure; it solely focuses on generating the <i>pyproject.toml</i> file.


title: INTERACTIVE VS. NON-INTERACTIVE
content:
When run without the <i>--no-interaction</i> flag, <b>poetry-init</b> will guide you through a series of prompts to gather project details. This is ideal for initial setup. For scripting or automated environments, using <i>-n</i> with other options like <i>--dependency</i> and <i>--license</i> allows for fully unattended project initialization.


title: CONFIGURING PROJECT METADATA
content:
The information provided during <b>poetry-init</b> (name, version, description, authors, license) populates the <i>[tool.poetry]</i> section of the <i>pyproject.toml</i>. This metadata is crucial for packaging, publishing, and proper project identification.


title: HISTORY
content:
The <b>poetry-init</b> command has been a fundamental part of the Poetry dependency management tool for Python since its early development stages, which began around 2017. Its core functionality—to create or update the <i>pyproject.toml</i> file—has remained largely consistent, evolving primarily with general improvements and enhancements to the Poetry ecosystem itself, such as better dependency resolution and metadata handling.


title: PARAMETERS
content:
<b><b>-u</b>, <b>--users</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Reports on user activity, showing counts of events per user.<br><br><b><b>-s</b>, <b>--success</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Filters the report to include only successful events.<br><br><b><b>-f</b>, <b>--file</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Generates a report focused on file and directory access events.<br><br><b><b>-l</b>, <b>--login</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Provides a summary of user login and logout events.<br><br><b><b>-h</b>, <b>--host</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Reports on events originating from different hosts.<br><br><b><b>-x</b>, <b>--executable</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Summarizes events related to executable programs being run.<br><br><b><b>-e</b>, <b>--event</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Reports on the types of audit events recorded.<br><br><b><b>-m</b>, <b>--mods</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Displays a summary of system modification events.<br><br><b><b>-A</b>, <b>--auth</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Reports on authentication-related events.<br><br><b><b>--start</b> <i><timestamp></i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Filters events to include those occurring on or after the specified timestamp.<br><br><b><b>--end</b> <i><timestamp></i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Filters events to include those occurring on or before the specified timestamp.<br><br><b><b>-i</b>, <b>--interpret</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Interprets numeric entities (like UIDs, GIDs, SIDs) into human-readable names.<br><br><b><b>--input</b> <i><file></i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Reads audit log data from the specified file instead of the default location.<br><br><b><b>-F</b>, <b>--format</b> <i><TEXT|XML|JSON></i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specifies the output format for the report (default is plain text).<br><br><b><b>--summary-users</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Provides a condensed summary of user activity.<br><br><b><b>--summary-failures</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Gives a summary of all audit failures.<br><br>


title: DESCRIPTION
content:
<b>aureport</b> is a powerful command-line utility for generating summaries and reports from the Linux Auditing System logs. It processes the raw audit records, typically found in <i>/var/log/audit/audit.log</i>, and presents them in a human-readable, aggregated format. This tool is indispensable for system administrators and security professionals to gain insights into system activity, detect security breaches, monitor user behavior, and ensure compliance with security policies. <b>aureport</b> can summarize various aspects of system events, including user logins, file access, privilege escalations, successful and failed authentication attempts, and command executions. Its diverse reporting capabilities allow for quick analysis of audit trails without needing to parse the raw log files manually, making audit log analysis more efficient and actionable.


title: CAVEATS
content:
<b>aureport</b> relies on the Linux Auditing System (<i>auditd</i>) to be properly configured and running to collect audit events. <br>Performance can be significantly impacted when processing very large audit logs, especially when using the <b>-i</b> (<i>--interpret</i>) option due to numerous lookups. <br>The accuracy and detail of reports are directly dependent on the audit rules defined by <i>auditctl</i> or <i>augenrules</i>. <br>Default log file location is usually <i>/var/log/audit/audit.log</i>, but this can vary based on <i>auditd.conf</i>.


title: POWERFUL FILTERING
content:
Beyond basic time ranges, <b>aureport</b> supports filtering by success/failure, specific event types, and allows for highly granular analysis of audit trails to pinpoint critical security incidents or compliance deviations.


title: OUTPUT FLEXIBILITY
content:
While its primary output is human-readable text, the command offers options to output data in XML or JSON formats, facilitating integration with other log analysis tools, security information and event management (SIEM) systems, or custom scripts for automated processing.


title: HISTORY
content:
<b>aureport</b> is an integral part of the Linux Audit Framework, primarily developed by Red Hat. It emerged as a crucial tool alongside <i>auditd</i>, <i>auditctl</i>, and <i>ausearch</i> to provide comprehensive security auditing capabilities for Linux systems. Its development has focused on enhancing the ability of administrators to quickly understand and report on system events for security monitoring, compliance (such as PCI DSS, HIPAA, SOX), and forensic analysis, continuously evolving to meet the demands of modern system security.


title: TLDR
content:
<b>Display a summary of auditd events</b>`sudo aureport`<br><b>Generate a summary of login events</b>`sudo aureport [[-l|--login]]`<br><b>List all syscall reports</b>`sudo aureport [[-s|--syscall]]`<br><b>Generate a summary of executable events</b>`sudo aureport [[-x|--executable]]`<br><b>Show a summary of events for a specific time range</b>`sudo aureport [[-ts|--start]] [start_time] [[-te|--end]] [end_time]`<br><b>List all audit files and the time range of events they cover</b>`sudo aureport [[-t|--log-time]]`<br><b>Display help</b>`aureport --help`


title: PARAMETERS
content:
<b>-f <I>scriptfile</I></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specifies the name of the output Expect script file. Default is <I>script.exp</I>.<br><br><b>-P <I>prefix</I></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Sets a prefix for temporary files used by <I>autoexpect</I>.<br><br><b>-C <I>chardelay</I></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Adds a delay (in milliseconds) after each character sent by the generated script during playback. Useful for slow systems or applications.<br><br><b>-T <I>timeout</I></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Sets the default timeout (in seconds) for <I>expect</I> commands within the generated script.<br><br><b>-D <I>debugfile</I></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Records debugging information from the generated <I>Expect</I> script to the specified file.<br><br><b>-l <I>logfile</I></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Logs the entire terminal session (input and output) to the specified file, in addition to generating the script.<br><br><b>-r</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Forces <I>autoexpect</I> to use raw mode, preventing interpretation of special characters like backspaces or control sequences.<br><br><b>-t</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Includes timestamps for events in the generated script, which can be useful for analysis.<br><br><b>-s</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Causes <I>autoexpect</I> to output the 'send' commands when creating the script.<br><br><b>-a</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Appends the generated Expect script to the specified output file instead of overwriting it.<br><br><b><I>command</I> [<I>args ...</I>]</b><br>&nbsp;&nbsp;&nbsp;&nbsp;The command and its arguments to execute and record during the session. If omitted, <I>autoexpect</I> starts a shell.<br><br>


title: DESCRIPTION
content:
<I>autoexpect</I> is a utility that automates the creation of <I>Expect</I> scripts by observing an interactive session. When launched, it records all user input and program output within a terminal. Upon completion of the session, <I>autoexpect</I> translates this recorded interaction into a runnable <I>Expect</I> script.<br><br>This generated script can then be used to automatically replay the exact sequence of commands and responses, effectively automating tasks that require human interaction, such as logging into remote servers, installing software, or running interactive diagnostic tools. It significantly simplifies the process of writing complex <I>Expect</I> scripts manually, reducing potential errors and saving considerable development time for repetitive or testing scenarios. While providing a robust starting point, the resulting script often requires manual refinement for increased robustness and flexibility.


title: CAVEATS
content:
<I>Autoexpect</I> generates scripts based on exact observed interactions, making them potentially 'fragile.' Minor changes in the interactive program's output (e.g., slight variations in prompts, timing differences, or new lines) can break the generated script.<br><br>For robust automation, the generated script almost always requires manual editing to generalize patterns, handle variable input, incorporate error checking, and manage sensitive information like passwords more securely. It may also include redundant or overly specific <I>expect</I> patterns that need simplification.


title: HOW IT WORKS
content:
<I>Autoexpect</I> operates by creating a pseudo-terminal (pty) and inserting itself between the user's terminal and the program being run. It monitors all data passing through this pty, capturing everything typed by the user and everything output by the program. Based on this observation, it constructs an <I>Expect</I> script using <I>expect</I> commands to wait for specific output patterns and <I>send</I> commands to reproduce the user's input. The generated script effectively mimics the recorded interactive session.


title: BEST PRACTICES
content:
While <I>autoexpect</I> provides a great starting point, always review and refine the generated script. Replace hardcoded strings with regular expressions where appropriate (e.g., `expect -re "(yes/no)"`). Use variables for sensitive data like passwords instead of embedding them directly. Add comments to explain complex logic. Test the script thoroughly in various scenarios to ensure its robustness against minor environmental changes or unexpected program outputs.


title: HISTORY
content:
The <I>Expect</I> tool, which <I>autoexpect</I> is a part of, was developed by Don Libes at the National Institute of Standards and Technology (NIST) in the early 1990s.<br><br><I>Autoexpect</I> itself emerged as a powerful utility accompanying the <I>Expect</I> package, designed to lower the barrier to entry for users wanting to automate interactive processes without deep knowledge of the <I>Expect</I> syntax. Its development reflects the need for simpler script generation in complex automation environments, leveraging <I>Expect</I>'s capabilities to observe and record real-time terminal interactions.


title: TLDR
content:
<b>Spawn a shell and generate a script from it</b>`autoexpect`<br><b>Run a command and generate a script from it</b>`autoexpect [command]`<br><b>Run a command, generate a script, and save the script to a specified file</b>`autoexpect -f [path/to/file] [command]`


title: TLDR
content:
<b>Filter reverse line feeds from input</b>`[command] | col`<br><b>Filter reverse line feeds and output with spaces instead of tabs</b>`[command] | col [[-x|--spaces]]`<br><b>Remove backspaces, output only the last character written to each position</b>`[command] | col [[-b|--no-backspaces]]`<br><b>Specify a buffer size with a specific number of lines</b>`[command] | col [[-l|--lines]] [num]`<br><b>Format a manual page for viewing with less</b>`man ls | col [[-b|--no-backspaces]] | less`<br><b>Process a file with reverse line feeds and save the cleaned output</b>`cat [path/to/input_file] | col [[-x|--spaces]] > [output_file]`


title: TLDR
content:
<b>List partitions</b>`sudo gdisk [[-l|--list]]`<br><b>Start the interactive partition manipulator</b>`sudo gdisk [/dev/sdX]`<br><b>Open a help menu</b>`<?>`<br><b>Print the [p]artition table</b>`<p>`<br><b>Add a [n]ew partition</b>`<n>`<br><b>Select a partition to [d]elete</b>`<d>`<br><b>[w]rite table to disk and exit</b>`<w>`<br><b>[q]uit without saving changes</b>`<q>`


title: PARAMETERS
content:
<b><b>-h</b>, <b>--help</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Display a help message and exit.<br><br><b><b>-v</b>, <b>--verbose</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Show more verbose output, including object attributes and CPU/NUMA node sets. Can be used multiple times for even more detail.<br><br><b><b>-i</b> <<i>filename</i>>, <b>--input</b> <<i>filename</i>></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Read the topology from the specified XML file instead of detecting it from the current system. This allows for offline analysis of saved topologies.<br><br><b><b>-o</b> <<i>filename</i>>, <b>--output</b> <<i>filename</i>></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Export the detected topology to an XML file. This XML can later be used with the <b>-i</b> option or other <i>hwloc</i> tools.<br><br><b><b>-p</b>, <b>--physical</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Display physical indexes for objects (e.g., physical CPU IDs) instead of logical indexes (default).<br><br><b><b>--cpuset</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Show the CPU set (a bitmap of CPUs) associated with each object in the topology.<br><br><b><b>--whole-system</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Report the entire system topology, even if some parts are not available to the current process due to cgroups or other resource restrictions.<br><br><b><b>--no-io</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Do not show I/O devices (e.g., PCI devices, network interfaces, GPUs) in the topology output.<br><br><b><b>--numa-only</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Filter the output to show only NUMA nodes and their children, hiding other object types.<br><br><b><b>--only</b> <<i>type</i>></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Only show objects of the specified type (e.g., <i>Core</i>, <i>L3Cache</i>, <i>NUMANode</i>). Case-insensitive.<br><br><b><b>--avoid</b> <<i>type</i>></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Avoid showing objects of the specified type in the output.<br><br><b><b>--xml</b>, <b>--dot</b>, <b>--ascii</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specify the output format: <b>--xml</b> for XML, <b>--dot</b> for Graphviz DOT, or <b>--ascii</b> for plain text (default).<br><br><b><b>--pid</b> <<i>pid</i>></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Restrict the topology to the CPU set (and NUMA nodes) of the specified process ID. This shows the hardware resources visible to a particular process.<br><br>


title: DESCRIPTION
content:
<i>hwloc-ls</i> is a command-line utility from the <b>hwloc</b> (Hardware Locality) project designed to visualize the architectural topology of a computing system. It presents a detailed, hierarchical view of hardware components such as processors, cores, threads, various levels of caches (L1, L2, L3), NUMA (Non-Uniform Memory Access) nodes, and I/O devices (e.g., PCI devices, network interfaces, GPUs).<br><br>The tool is invaluable for understanding how these components are interconnected and their relative proximity. This locality information is critical for optimizing the performance of parallel applications, configuring efficient resource allocation, and diagnosing performance bottlenecks, particularly in high-performance computing (HPC) environments. It helps users make informed decisions about CPU affinity, memory placement, and task scheduling to minimize latency and maximize throughput. <i>hwloc-ls</i> can display the topology of the local system or load it from an XML file for offline analysis or remote system examination.


title: CAVEATS
content:
<i>hwloc-ls</i> relies on system information provided by the operating system kernel and various filesystem entries (e.g., <b>/proc</b>, <b>/sys</b>).<br><br><b>Permissions:</b> Insufficient permissions might prevent <i>hwloc-ls</i> from accessing complete topology information, especially concerning I/O devices or process-specific details.<br><b>Kernel Support:</b> The level of detail and accuracy can vary depending on the operating system, kernel version, and installed drivers.<br><b>Verbose Output:</b> For systems with a large number of components, the ASCII output can be very lengthy and complex to parse manually.<br><b>XML/DOT Support:</b> For XML input/output, the <i>hwloc</i> library must have been compiled with <b>libxml2</b> support. For DOT output, <b>Graphviz</b> tools are required to render the graph.


title: OUTPUT HIERARCHY
content:
<i>hwloc-ls</i> presents the system topology in a clear, tree-like hierarchy. The top-level object is typically the <i>Machine</i>. Below that, you might find <i>Package</i> (CPU sockets), <i>NUMANode</i>, different levels of caches (<i>L3Cache</i>, <i>L2Cache</i>, <i>L1Cache</i>), <i>Core</i>, and finally <i>PU</i> (Processing Unit, which usually corresponds to a hardware thread). I/O devices are typically attached to the lowest-level common ancestor.


title: TOPOLOGY SOURCES
content:
By default, <i>hwloc-ls</i> detects the topology of the system it's running on. However, its flexibility allows it to read topology information from an XML file. This feature is crucial for debugging, analyzing, or simulating workloads on a system without direct access, by loading a previously saved topology definition.


title: HISTORY
content:
The <b>hwloc</b> project, including the <i>hwloc-ls</i> utility, originated from the fusion of two earlier projects: INRIA's <i>libtopology</i> and the Open MPI project's <i>PLPA</i> (Portable Linux Processor Affinity). This merge, occurring around 2009, aimed to create a robust and cross-platform standard for hardware locality information. <i>hwloc-ls</i> quickly became a cornerstone utility, providing a consistent way to expose complex system architectures, which is vital for developing and optimizing parallel software, especially in high-performance computing (HPC) environments where CPU and memory locality are paramount for performance.


title: SYNOPSIS
content:
<b>koji buildinfo</b> [<i>COMMON_OPTIONS</i>] <i>&lt;build_identifier&gt;</i><br><i>build_identifier</i>: Koji build ID (integer) or Name-Version-Release (NVR) string.<br><i>COMMON_OPTIONS</i>: Standard <b>koji</b> client options applicable to most commands.


title: PARAMETERS
content:
<b><i>&lt;build_identifier&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;The mandatory identifier for the build to query. This can be either the numeric Koji build ID (e.g., <i>12345</i>) or a Name-Version-Release (NVR) string (e.g., <i>my-package-1.0-1.fc34</i>).<br><br><b><b>-h</b>, <b>--help</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Show the program's help message and exit. This will display general <b>koji</b> client options and a brief usage for <b>buildinfo</b>.<br><br><b><b>--config=</b><i>FILE</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specify an alternate configuration <i>FILE</i> for the <b>koji</b> client instead of the default <i>~/.koji/config</i> or <i>/etc/koji.conf</i>.<br><br><b><b>--hub=</b><i>URL</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Connect to a specific <b>Koji</b> hub at the given <i>URL</i>, overriding the configured default.<br><br><b><b>--weburl=</b><i>URL</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specify the base <i>URL</i> for the <b>Koji</b> web interface associated with the hub, primarily for informational purposes or to generate links.<br><br><b><b>--debug</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Enable debug logging, providing more detailed output useful for troubleshooting connection issues or unexpected behavior.<br><br><b><b>-q</b>, <b>--quiet</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Suppress most output, showing only critical messages or errors.<br><br><b><b>-v</b>, <b>--verbose</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Increase verbosity of the output, providing more detailed status messages.<br><br><b><b>--timeout=</b><i>SECONDS</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Set a network timeout in <i>SECONDS</i> for operations, preventing indefinite hangs on unresponsive servers.<br><br><b><b>--authtype=</b><i>TYPE</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specify the authentication <i>TYPE</i> to use (e.g., <i>kerberos</i>, <i>ssl</i>). This is crucial for accessing protected hubs or privileged information.<br><br>


title: DESCRIPTION
content:
The <b>koji-buildinfo</b> command (or more commonly invoked as <b>koji buildinfo</b>) is a fundamental utility within the <b>Koji</b> build system client, primarily used for retrieving comprehensive details about a specific build. <b>Koji</b> itself is a powerful, open-source build system developed by Red Hat, widely adopted for building RPM packages for Fedora, Red Hat Enterprise Linux, and other distributions.<br><br>This command provides a detailed snapshot of a build identified either by its unique numeric ID or its Name-Version-Release (NVR) string. The information displayed typically includes vital metadata such as the build ID, package name, version, release, current state (e.g., complete, failed), owner, creation and completion timestamps, associated build target and tags, and a list of all RPM packages produced by that build. It also provides details about the build source, such as the Git repository and commit hash.<br><br>Its primary use cases involve debugging build failures, verifying build provenance, auditing components, and understanding the lifecycle of a specific software build within the <b>Koji</b> infrastructure. It's an essential tool for developers, release engineers, and quality assurance teams working with Koji.


title: CAVEATS
content:
Requires network connectivity to a running <b>Koji</b> hub. The level of detail and access to sensitive build information might depend on the user's authentication and permissions configured on the <b>Koji</b> hub.<br>The command's output is typically human-readable plain text, which can be verbose and may require text processing tools like <b>grep</b> or <b>awk</b> for programmatic extraction of specific fields, as it does not inherently offer structured output like JSON or XML.


title: <I>OUTPUT FORMAT</I>
content:
The output typically provides a human-readable, multi-line display of various build attributes, including identification, state, timestamps, associated packages (RPMs), build target, and source information. It's primarily designed for direct inspection rather than programmatic parsing, though basic text processing can extract specific fields.


title: <I>BUILD IDENTIFIERS</I>
content:
The <i>&lt;build_identifier&gt;</i> argument is flexible, accepting either a numeric Koji build ID (e.g., <i>12345</i>) or a Name-Version-Release (NVR) string (e.g., <i>my-package-1.0-1.fc34</i>). Using an NVR allows specifying a particular build of a package without prior knowledge of its internal ID, which is often convenient.


title: HISTORY
content:
The <b>Koji</b> build system was initiated at Red Hat to streamline the build process for Fedora and later Red Hat Enterprise Linux. As a core client component, <b>koji buildinfo</b> has been integral since the early development of the <b>Koji</b> client, serving as a primary interface for querying build metadata. Its design reflects the need for immediate, detailed introspection into the state and provenance of software packages within a robust build environment. The command has evolved primarily through enhancements to the underlying <b>Koji</b> API and client infrastructure rather than significant changes to its fundamental function or syntax.


title: SEE ALSO
content:
<b>koji</b>(1): The main <b>Koji</b> client command, providing access to a wide range of build system functions., <b>koji list-builds</b>(1): Lists builds based on various criteria (e.g., package, tag, state)., <b>koji latest-build</b>(1): Retrieves information about the most recent successful build for a given package., <b>rpm</b>(8): The standard Linux package manager, relevant for understanding the packages produced by Koji builds.


title: TLDR
content:
<b>Print basic information</b>`koji buildinfo [BuildID_or_NVR1 BuildID_or_NRV2 ...]`<br><b>Print basic information with changelog</b>`koji buildinfo [BuildID_or_NVR1 BuildID_or_NRV2 ...] --changelog`<br><b>Display help</b>`koji buildinfo --help`


title: TLDR
content:
<b>Call build function with scratch option</b>`koji call build '"[git+https://src.fedoraproject.org/rpms/vim.git#e847a50297a216229050bf4db3d06a139104e7cf]"' \"[target]\" --kwargs '{"opts":{"scratch": True]'`<br><b>Call build function with arch_override option</b>`koji call build '"[git+https://src.fedoraproject.org/rpms/vim.git#e847a50297a216229050bf4db3d06a139104e7cf]"' \"[target]\" --kwargs '{"opts":{"arch_override":"sw_64"]'`<br><b>Call build function on default channel</b>`koji call build '"[git+https://src.fedoraproject.org/rpms/vim.git#e847a50297a216229050bf4db3d06a139104e7cf]"' \"[target]\" --kwargs '{"channel":"default"}'`<br><b>Display help</b>`koji call --help`


title: SYNOPSIS
content:
koji-cancel [<i>options</i>] <<i>TASK_ID</i>> [<<i>TASK_ID</i>> ...]<br>koji-cancel [<i>options</i>] --tag <<i>TAG_NAME</i>>


title: PARAMETERS
content:
<b>--help, -h</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Show a help message and exit.<br><br><b>--debug, -d</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Print debugging output for verbose operations.<br><br><b>--quiet, -q</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Do not print status messages during execution.<br><br><b>--tag <<i>TAG_NAME</i>></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Cancel all tasks associated with a specific Koji tag.<br><br><b>--force, -f</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Do not prompt for confirmation when canceling tasks, especially when using the <i>--tag</i> option.<br><br><b>--hub <<i>URL</i>></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specify the URL of the Koji hub to connect to. Overrides the default configured hub.<br><br><b>--weburl <<i>URL</i>></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specify the URL of the Koji web interface. Overrides the default configured URL.<br><br><b>--config <<i>FILE</i>></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Use the specified configuration file instead of the default.<br><br><b>--session <<i>FILE</i>></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Use a specified session file for authentication, typically for existing authenticated sessions.<br><br><b>--user <<i>USERNAME</i>></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specify the Koji username for authentication.<br><br><b>--password <<i>PASSWORD</i>></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specify the Koji password for authentication. Not recommended for interactive use due to security concerns.<br><br><b>--keytab <<i>FILE</i>></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specify the Kerberos keytab file to use for authentication.<br><br><b>--principal <<i>PRINCIPAL</i>></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specify the Kerberos principal to use for authentication.<br><br>


title: DESCRIPTION
content:
Koji is a distributed build system primarily used by Fedora and Red Hat for building RPM packages and other software artifacts. The `koji-cancel` command provides a mechanism to terminate or abort ongoing tasks within the Koji system. This is crucial for managing build resources, stopping erroneous builds, or halting tasks that are no longer needed.<br><br>When invoked, `koji-cancel` communicates with the Koji hub to mark specified tasks as 'canceled'. This action prevents the task from progressing further and frees up build resources. Users typically cancel tasks by their unique integer task ID. It's also possible to cancel all tasks associated with a particular build tag, though this is a more aggressive operation. The command requires appropriate Koji user permissions to execute a cancel operation.


title: CAVEATS
content:
<b>Permissions:</b> Users must have appropriate Koji permissions (e.g., <i>admin</i> or <i>cancel</i> permission) to cancel tasks. Unauthorized attempts will fail.<br><br><b>Irreversibility:</b> Once a task is canceled, it cannot be resumed. A new task must be submitted if the build is still desired.<br><br><b>Timing:</b> A task might not be immediately canceled if it's already in a critical stage or nearing completion. The Koji builder client still needs to acknowledge and process the cancellation request.<br><br><b>Resource Release:</b> While cancellation stops a task, it may take some time for associated resources (e.g., build roots, chroots) to be fully cleaned up and released by the builder.


title: EXIT STATUS
content:
The `koji-cancel` command typically exits with `0` on success and a non-zero value on error. Non-zero values indicate issues such as tasks not found, authentication failures, insufficient permissions, or network problems.


title: CONFIGURATION FILES
content:
Koji client commands, including `koji-cancel`, often rely on configuration files (e.g., `~/.koji/config` or `/etc/koji.conf`) to define default hub URLs, authentication methods, and other settings. This reduces the need for explicit command-line options for common operations.


title: HISTORY
content:
The Koji build system was originally developed by Red Hat as the successor to the `mock` and `pungi` tools, becoming the official build system for Fedora. The `koji-cancel` command has been a fundamental part of the Koji client utility suite since the early stages of Koji's development. Its necessity arose from the need to manage and control numerous build tasks running concurrently across distributed builders, allowing administrators and authorized users to respond to build failures, resource contention, or changing priorities efficiently. The command's core functionality has remained consistent, evolving alongside the broader Koji system and its authentication mechanisms (e.g., Kerberos support).


title: TLDR
content:
<b>Cancel a task by its ID</b>`koji cancel [task_id]`<br><b>Cancel multiple tasks</b>`koji cancel [task_id1 task_id2 ...]`<br><b>Cancel a task with verbose output</b>`koji cancel --verbose [task_id]`<br><b>Display help</b>`koji cancel [[-h|--help]]`


title: PARAMETERS
content:
<b><b>--all</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Download <i>all</i> available artifacts (RPMs, SRPMs, debuginfo, logs, etc.) for the specified build.<br><br><b><b>--rpm</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Download only the binary RPM packages. This is the default if no specific type is chosen.<br><br><b><b>--srpm</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Download only the Source RPM (SRPM) packages.<br><br><b><b>--debuginfo</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Download only the debuginfo RPM packages.<br><br><b><b>--logs</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Download build log files.<br><br><b><b>--arch</b> <i>&lt;arch&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Filter downloaded RPMs by a specific architecture (e.g., `x86_64`, `noarch`). This option can be used multiple times.<br><br><b><b>--dstdir</b> <i>&lt;directory&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specify the destination directory where artifacts will be saved. Defaults to the current working directory.<br><br><b><b>--scratch</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Include artifacts from scratch builds (temporary builds not intended for release).<br><br><b><b>--build</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Explicitly treat arguments as Koji build IDs (numeric).<br><br><b><b>--nvr</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Explicitly treat arguments as NVR (Name-Version-Release) strings.<br><br><b><b>--fail-on-missing</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Exit with an error status if a requested artifact type (e.g., debuginfo) is not found for a build.<br><br><b><b>-h</b>, <b>--help</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Display a help message and exit.<br><br><b><b>--version</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Show program's version number and exit.<br><br>


title: DESCRIPTION
content:
The `<b>koji-download-build</b>` command is a client-side utility within the Koji build system ecosystem, primarily used to retrieve various artifacts from completed software builds. It enables users to download RPM packages, Source RPMs (SRPMs), debuginfo packages, build logs, and other outputs for a specified build. Builds are identified by their unique Name-Version-Release (NVR) string or numeric ID. This tool is indispensable for developers, QA engineers, and release managers in environments utilizing Koji for package building, allowing for efficient inspection, testing, and redistribution of built components. It communicates with the Koji hub to locate and download files, offering options to filter by architecture, artifact type, or specify a custom destination directory.


title: CAVEATS
content:
Requires network connectivity to the Koji hub and appropriate permissions to access build information and artifacts.<br>Can download large amounts of data, especially with the `<b>--all</b>` option, potentially consuming significant disk space and bandwidth.<br>The exact set of downloadable artifacts depends on the build type and what was produced during the Koji build process.


title: KOJI HUB INTERACTION
content:
This command communicates with the central Koji hub server to query detailed build information and retrieve the URLs for build artifacts. These artifacts are typically hosted on a separate content delivery network (CDN) or web server, ensuring efficient and scalable downloads.


title: TYPICAL USAGE
content:
It is frequently used in automated scripts for tasks such as testing, staging, or creating custom package repositories. For example, to download all `x86_64` RPMs and their corresponding debuginfo for `<i>my-package-1.0-1.fc39</i>`, one would execute: `<b>koji-download-build --rpm --debuginfo --arch x86_64 my-package-1.0-1.fc39</b>`.


title: HISTORY
content:
Koji is an open-source build system primarily developed by Red Hat for building Fedora, CentOS, and RHEL packages, aiming for a reliable, distributed, and scalable RPM build environment. `<b>koji-download-build</b>` emerged as an integral part of the Koji client utilities, designed to provide a straightforward interface for retrieving the diverse outputs of Koji builds. Its development has consistently focused on robustness, flexibility in artifact selection, and seamless integration with the Koji hub's API, evolving to support various artifact types like RPMs, SRPMs, debuginfo, and even newer formats such as container images and Golang modules.


title: TLDR
content:
<b>Download all RPMs from a specific build</b>`koji download-build [BuildID|RPM|NVR]`<br><b>Download RPMs signed with the given key</b>`koji download-build [BuildID|RPM|NVR] --key [key]`<br><b>Only download RPMs for given arch</b>`koji download-build [BuildID|RPM|NVR] --arch [x86_64,aarch64,noarch,...]`<br><b>Download the given RPM</b>`koji download-build [RPM] --rpm`<br><b>Display help</b>`koji download-build --help`


title: PARAMETERS
content:
<b><<i>tag</i>></b><br>&nbsp;&nbsp;&nbsp;&nbsp;The name of the Koji tag to which the build(s) should be associated. This tag must pre-exist in the Koji system and be accessible to the user.<br><br><b><<i>build</i>></b><br>&nbsp;&nbsp;&nbsp;&nbsp;The NVR (Name-Version-Release) string or the integer ID of the Koji build to tag. Multiple build arguments can be provided to tag several builds into the same tag simultaneously.<br><br><b><b>-h</b>, <b>--help</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Show the help message for the command and exit.<br><br><b><b>--debug</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Enable debug output, providing more verbose information about the command's execution and internal operations.<br><br><b><b>--quiet</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Suppress standard output, only displaying error messages if they occur during the operation.<br><br><b><b>--strict</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Apply strict checking. While its primary use is with <b>untag-build</b> to ensure a build is only removed from specified tags, for <b>tag-build</b> it can enforce specific Koji policies or behaviors if configured by the hub.<br><br><b><b>--user=</b><i>USER</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specify the username for explicit authentication with the Koji hub. This is typically used in conjunction with <b>--password</b> if not relying on Kerberos or client certificates for authentication.<br><br><b><b>--password=</b><i>PASSWORD</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Provide the password for authentication with the Koji hub. This option should always be used with <b>--user</b>. For enhanced security, using client certificates or Kerberos is generally preferred over plaintext password input.<br><br><b><b>--url=</b><i>URL</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specify an alternative URL for the Koji hub. This overrides the default hub URL configured in the Koji client configuration file or environmental variables.<br><br><b><b>--config=</b><i>CONFIG</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specify an alternative Koji client configuration file to use. This allows overriding the default configuration files located at <i>~/.koji/config</i> or system-wide paths.<br><br><b><b>--session=</b><i>SESSION</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Use a pre-existing Koji session ID for authentication. This bypasses the need for explicit user/password or certificate-based login for the current command execution, reusing an active session.<br><br><b><b>--skip-check</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Skip some internal checks, such as verifying if the build is already tagged into the specified tag. Use this option with caution, as it can override existing conditions or policy checks without warning, potentially leading to redundant entries or unexpected states.<br><br>


title: DESCRIPTION
content:
The <b>koji-tag-build</b> command is a fundamental client-side utility within the Koji build system. Koji is an open-source build system primarily used for RPM package building and management, notably within Fedora, CentOS, and other RPM-based distributions.<br><br>This command's primary function is to associate an existing, completed Koji build with one or more specified Koji <i>tags</i>. In Koji, a tag acts as a logical grouping mechanism, often representing a release stream, a development branch, or a specific stage in a software development lifecycle (e.g., 'f39-updates-candidate', 'epel9').<br><br>By tagging a build, you make it discoverable and available under that tag. This is crucial for promoting builds from a testing tag to a release tag, or for ensuring that a specific version of a package is included in a particular repository. Builds can belong to multiple tags simultaneously, allowing for flexible management of build states and availability across different contexts. Successful execution of this command requires appropriate permissions on the Koji hub for the target tag.


title: CAVEATS
content:
Using <b>koji-tag-build</b> requires appropriate permissions within the Koji system. Only Koji administrators or users with specific roles (e.g., 'tag' permission on the target tag) can successfully execute this command. Incorrectly tagging builds can lead to unexpected package availability or conflicts within repositories. Be particularly cautious when using the <b>--skip-check</b> option, as it can bypass safeguards designed to prevent duplicate tagging or other policy violations, potentially causing unintended side effects in your Koji environment. Always ensure the specified tag is the correct and intended destination for the build to avoid publishing unintended versions or confusing repository contents.


title: EXAMPLE USAGE
content:
Here are some common ways to use <b>koji-tag-build</b>:<br><br><i>Tag a single build into a development tag:</i><br><code>koji tag-build f39-candidate mypackage-1.0-1.fc39</code><br><br><i>Tag multiple builds into a release tag, assuming you have a Koji configuration file set up:</i><br><code>koji tag-build f39-release myotherpackage-2.1-3.fc39 anotherpackage-0.5-1.fc39</code><br><br><i>Tag a build using its numeric ID instead of NVR:</i><br><code>koji tag-build epel9-testing 1234567</code><br><br><i>Tag a build and skip checks (use with extreme caution):</i><br><code>koji tag-build --skip-check rawhide newfeature-3.0-1.fc40</code>


title: HISTORY
content:
The <b>koji-tag-build</b> command is an integral part of the Koji build system, which was originally developed by Red Hat and first released around 2005-2006 to manage the complexities of building and maintaining RPM packages for Fedora and Red Hat Enterprise Linux. As a core function for build promotion and lifecycle management, the ability to tag builds has been present since the early versions of Koji. Its design reflects the need for robust, auditable control over what packages are included in various release stages and repositories, evolving alongside the Koji project to support modern build workflows and distributed development environments.


title: SEE ALSO
content:
koji(1), koji-build(1), koji-untag-build(1), koji-list-tags(1), koji-list-builds(1), koji-tag-pkg(1)


title: TLDR
content:
<b>Apply a tag to one or more builds</b>`koji tag-build [tag] [NVR1 NVR2 ...]`<br><b>Don't wait on task</b>`koji tag-build [tag] [NVR1 NVR2 ...] --nowait`<br><b>Force operation</b>`koji tag-build [tag] [NVR1 NVR2 ...] --force`<br><b>Display help</b>`koji tag-build --help`


title: SYNOPSIS
content:
<b>koji-taginfo</b> [<i>options</i>] <i>&lt;tag_name&gt;</i> [<i>&lt;tag_name&gt;</i> ...]<br><br><i>Explanation:</i><br><ul><li><b>koji-taginfo</b>: The command itself.</li><li>[<i>options</i>]: Optional flags that modify the command's behavior.</li><li><i>&lt;tag_name&gt;</i>: The name of the Koji tag for which to retrieve information. Multiple tag names can be specified, separated by spaces.</li></ul>


title: PARAMETERS
content:
<b><i>&lt;tag_name&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;The name of the Koji tag (or tags) for which to retrieve detailed information. Multiple tags can be specified as positional arguments.<br><br><b><b>-h</b>, <b>--help</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Show the help message and exit.<br><br><b><b>--debug</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Enable debug output, providing more verbose information for troubleshooting.<br><br><b><b>--config</b> <i>&lt;file&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specify an alternate Koji configuration file to use instead of the default.<br><br><b><b>--server</b> <i>&lt;url&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specify the Koji XML-RPC server URL to connect to.<br><br><b><b>--weburl</b> <i>&lt;url&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specify the Koji web interface URL.<br><br><b><b>--topurl</b> <i>&lt;url&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specify the Koji top URL, often used for content and repository access.<br><br><b><b>--login</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Force a new login session, discarding any existing session tokens.<br><br><b><b>--session</b> <i>&lt;id&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Use a specific Koji session ID for authentication.<br><br><b><b>--json</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Output the tag information in JSON format, suitable for scripting and programmatic parsing.<br><br>


title: DESCRIPTION
content:
The <I>koji-taginfo</I> command is a Koji client utility used to retrieve and display detailed information about one or more specified Koji tags.<br><br>Koji tags are fundamental to the Koji build system, representing specific points in a build process, such as a release branch, a development stream, or an architecture-specific grouping. This command allows users to inspect a tag's attributes, including its name, ID, creation time, associated event IDs, and parent/child tag relationships.<br><br>It's an essential tool for system administrators, release engineers, and developers who need to understand the configuration and hierarchy of tags within their Koji instance, troubleshoot build assignments, or verify tag settings. The output helps in managing build policies, ensuring proper inheritance of buildroots, and maintaining a clear overview of the build environment.


title: CAVEATS
content:
The <I>koji-taginfo</I> command requires the Koji client tools to be properly installed and configured.<br>Network connectivity to the Koji hub server is essential for its operation. Users must have the necessary permissions within Koji to access and view the requested tag information; otherwise, an authentication or authorization error may occur.<br>The exact output format and the level of detail provided can sometimes vary slightly depending on the specific Koji server version and its configuration.


title: USAGE EXAMPLES
content:
To get information about a single tag named <I>f24-build</I>:<br><pre><b>koji-taginfo</b> f24-build</pre><br>To retrieve information for multiple tags and output it in JSON format:<br><pre><b>koji-taginfo</b> --json f25-candidate f26-master</pre><br>To debug connection issues while getting tag info:<br><pre><b>koji-taginfo</b> --debug <I>some-tag</I></pre>


title: TAG INHERITANCE AND RELATIONSHIPS
content:
Koji tags often form a hierarchical structure, where child tags inherit properties from parent tags. The information provided by <I>koji-taginfo</I> helps in understanding these inheritance chains, which is crucial for determining how buildroots are composed and how builds are promoted through different stages (e.g., from <I>rawhide</I> to a specific release tag).


title: TLDR
content:
<b>Print basic information</b>`koji taginfo [tag1 tag2 ...]`<br><b>Display help</b>`koji taginfo --help`


title: PARAMETERS
content:
<b><<i>tag_name</i>></b><br>&nbsp;&nbsp;&nbsp;&nbsp;The name of the tag from which the build should be removed. This is a required argument.<br><br><b><<i>build_name_or_id</i>></b><br>&nbsp;&nbsp;&nbsp;&nbsp;The name (NVR: Name-Version-Release) or ID of the build to untag. This is a required argument.<br><br><b><b>--rpm</b> <<i>rpm_nvr</i>></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Untag only the specified RPM (by its NVR, e.g., 'mypkg-1.0-1.fc36') from the build. If this option is not used, the entire build is untagged from the specified tag.<br><br><b><b>--force</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Force the untagging operation, bypassing certain dependency checks. Use with caution as it can lead to inconsistent states if not fully understood.<br><br><b><b>--user</b> <<i>username</i>></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specify the Koji username for authentication. If not provided, Koji typically attempts to use Kerberos credentials or a client certificate.<br><br><b><b>--password</b> <<i>password</i>></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Provide the password for the specified Koji user. It's generally recommended to avoid passing passwords directly on the command line for security reasons.<br><br><b><b>--web</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Authenticate using the Koji web interface, typically by opening a browser for login.<br><br><b><b>--debug</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Enable debug output, providing more verbose information about the command's execution and any potential issues.<br><br><b><b>--quiet</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Suppress most informational output, only showing errors or warnings.<br><br><b><b>--help</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Display a help message for the <i>untag-build</i> subcommand and exit.<br><br>


title: DESCRIPTION
content:
The <i>koji-untag-build</i> command is a critical utility within the Koji build system, primarily used to dissociate a previously tagged build from a particular tag. In the context of Koji, a 'build' represents compiled software artifacts (like RPMs), and a 'tag' acts as a logical grouping mechanism, often corresponding to specific releases, branches, or development stages (e.g., 'f36-updates', 'rawhide').<br><br>The primary purpose of untagging a build is to rectify errors or manage release stability. For instance, if a faulty build was inadvertently tagged into a stable release, or if a build needs to be removed from a testing tag due to new issues, this command facilitates that removal. It does <b>not</b> delete the build itself from the Koji hub; rather, it simply severs the link between the build and the specified tag. This action prevents the untagged build from being included in future composes or installations that reference that specific tag.


title: CAVEATS
content:
Untagging a build requires appropriate Koji permissions for the specified tag. Care must be taken, especially when using the <b>--force</b> option, as untagging builds can have cascading effects on dependent software or ongoing release processes. Untagging does <b>not</b> delete the build itself; it merely removes its association with a specific tag. Ensure you understand the impact before proceeding, particularly in production environments.


title: AUTHENTICATION METHODS
content:
Koji clients support various authentication methods, including Kerberos, client SSL certificates, and web-based authentication (<b>--web</b>). Users typically configure their preferred method in the <i>~/.koji/config</i> file. Using <b>--user</b> and <b>--password</b> directly on the command line is generally discouraged for scripts or shared environments due to security risks.


title: IMPACT ON COMPOSES AND REPOSITORIES
content:
When a build is untagged from a tag that is used for generating software repositories (composes), the untagged build will no longer appear in subsequent repository generations. This effectively removes the software from being available via that particular distribution channel, which is often the desired outcome when an erroneous or problematic build needs to be pulled back.


title: HISTORY
content:
Koji, developed primarily by Red Hat, has been the backbone of Fedora and Red Hat Enterprise Linux (RHEL) build systems since the mid-2000s. The <i>untag-build</i> command, like other core Koji client functionalities, has been an essential part of the Koji ecosystem from its early stages, evolving alongside the system's needs for robust build and release management. Its consistent presence highlights the enduring requirement for fine-grained control over which builds are associated with which release tags, crucial for maintaining software quality and release integrity.


title: SEE ALSO
content:
koji tag-build(1), koji buildinfo(1), koji list-builds(1), koji block-build(1), koji edit-tag(1), koji regen-pkg(1)


title: TLDR
content:
<b>Remove a tag from one or more builds</b>`koji untag-build [tag] [NVR1 NVR2 ...]`<br><b>Untag all versions of the package in this tag</b>`koji untag-build [tag] [pkg1 pkg2 ...] --all`<br><b>Untag all versions of the package in this tag except the latest</b>`koji untag-build [tag] [pkg1 pkg2 ...] --non-latest`<br><b>Test mode</b>`koji untag-build [tag] [NVR1 NVR2 ...] [[-n|--test]]`<br><b>Print details</b>`koji untag-build [tag] [NVR1 NVR2 ...] [[-v|--verbose]]`<br><b>Display help</b>`koji untag-build --help`


title: PARAMETERS
content:
<b><b>-h</b>, <b>--help</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Show help message and exit.<br><br><b><b>-v</b>, <b>--verbose</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Increase verbosity, showing more details about the topology.<br><br><b><b>-i</b> <i>&lt;file&gt;</i>, <b>--input</b> <i>&lt;file&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Read topology from an XML file generated by a previous <i>lstopo</i> run, instead of detecting the current machine's topology.<br><br><b><b>-c</b>, <b>--cpuset</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Display the cpuset for each object, showing which CPU cores are assigned to it.<br><br><b><b>-p</b>, <b>--physical</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Show physical (OS-assigned) indexes for objects, rather than logical (hwloc-assigned) indexes.<br><br><b><b>-l</b>, <b>--logical</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Show logical (hwloc-assigned) indexes for objects (this is the default behavior).<br><br><b><b>--no-io</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Do not show I/O devices in the output.<br><br><b><b>--no-bridges</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Do not show host bridges (PCI bridges) in the output.<br><br><b><b>--output-format</b> <i>&lt;format&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specify the output format explicitly. Supported formats include <i>xml</i>, <i>ascii</i>, <i>plain</i>, <i>curses</i>, <i>console</i>. This is implicitly handled by <i>lstopo-no-graphics</i> when a graphical output format is not specified.<br><br><b><b>--export-xml</b> <i>&lt;file&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Export the discovered topology to the specified XML file.<br><br><b>[<i>filename</i>]</b><br>&nbsp;&nbsp;&nbsp;&nbsp;If provided, the output is written to this file instead of standard output (stdout). The output format is inferred from the file extension if not specified with <b>--output-format</b> (e.g., .xml for XML, .txt for plain text).<br><br>


title: DESCRIPTION
content:
<i><b>lstopo-no-graphics</b></i> is a specialized variant of the <b>hwloc</b> (Hardware Locality) project's primary tool, <i>lstopo</i>. Its main purpose is to display the underlying hardware topology of a system, including information about CPUs, caches, NUMA nodes, memory, and I/O devices.<br><br>Unlike the default <i>lstopo</i>, this version is specifically designed to operate without any graphical dependencies or output. It provides topology information exclusively in textual or XML formats, making it ideal for use in environments where a graphical display is unavailable or undesirable. This includes SSH sessions, headless servers, scripting, or automated system analysis.<br><br>The command helps users and applications understand the machine's architecture, which is crucial for optimizing software performance by making informed decisions about process and data placement.


title: CAVEATS
content:
<b><i>lstopo-no-graphics</i></b> inherently cannot produce graphical output; it will always default to a text or XML representation. The accuracy and completeness of the topology information depend on the operating system's ability to expose hardware details. On complex systems, the textual output can be very large and require careful parsing. Some detailed hardware information might require root privileges to access. When reading from an input XML file, it assumes the input represents the topology as previously discovered, not the live system.


title: OUTPUT FORMATS
content:
<i><b>lstopo-no-graphics</b></i> supports several non-graphical output formats:<br><ul><li><b>ascii</b>: A detailed textual representation using ASCII characters for hierarchical structure.</li><li><b>plain</b>: A simpler, more compact textual output, often suitable for quick glances or parsing.</li><li><b>curses</b>: An interactive textual display (if a terminal supporting curses is detected), offering a more dynamic view.</li><li><b>console</b>: Similar to plain, designed for direct console output.</li><li><b>xml</b>: A structured XML format, ideal for programmatic parsing, saving, and later re-reading topology data.</li></ul>


title: USE CASES
content:
This command is invaluable for:<br><ul><li><b>High-Performance Computing (HPC)</b>: Optimizing MPI process placement and OpenMP thread affinity on multi-core, multi-socket, and NUMA architectures.</li><li><b>System Administration</b>: Understanding system resource layout for troubleshooting performance issues or planning resource allocation.</li><li><b>Scripting and Automation</b>: Collecting hardware topology information programmatically for inventory, configuration, or performance monitoring scripts.</li><li><b>Virtualization</b>: Analyzing the physical topology of a host or the exposed topology within a virtual machine.</li></ul>


title: HISTORY
content:
The <b>hwloc</b> (Hardware Locality) project was initiated around 2009 with the goal of providing a portable abstraction of hierarchical machine architectures. <i>lstopo</i> quickly became its flagship command-line tool. The <i><b>lstopo-no-graphics</b></i> variant emerged to specifically address environments lacking graphical capabilities, allowing the core functionality of topology discovery and display to be accessible everywhere, from supercomputers without X servers to simple SSH sessions. It represents a commitment to versatility and portability in hardware analysis tools.


title: TLDR
content:
<b>Display the machine topology in a tree format</b>`lstopo-no-graphics`<br><b>Display only physical cores (ignore logical processors)</b>`lstopo-no-graphics --only pu`<br><b>Display the topology with physical indexes</b>`lstopo-no-graphics [[-p|--physical]]`<br><b>Display help</b>`lstopo-no-graphics [[-h|--help]]`


title: TLDR
content:
<b>Start slabtop</b>`sudo slabtop`<br><b>Sort by [c]ache size</b>`sudo slabtop [[-s|--sort]] c`<br><b>Sort by number of [o]bjects</b>`sudo slabtop [[-s|--sort]] o`<br><b>Sort by object [s]ize</b>`sudo slabtop [[-s|--sort]] s`<br><b>Display once and then exit</b>`sudo slabtop [[-o|--once]]`<br><b>Display help</b>`slabtop [[-h|--help]]`


title: PARAMETERS
content:
<b><i>UNIT...</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;One or more <i>systemd</i> unit names (e.g., <b>apache2.service</b>, <b>nginx.service</b>, <b>network.target</b>). The <b>.service</b> suffix can often be omitted for service units.<br><br><b>--no-block</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Do not wait for the operation to finish. The command will exit immediately after issuing the request, allowing the process to continue in the background.<br><br><b>--user</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Operate on the user's <i>systemd</i> instance. By default, <b>systemctl</b> operates on the system <i>systemd</i> instance, requiring root privileges for most service management tasks.<br><br><b>--system</b><br>&nbsp;&nbsp;&nbsp;&nbsp;(Default) Operate on the system <i>systemd</i> instance. This is the default behavior and usually requires root privileges.<br><br><b>--fail</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Return a non-zero exit code if the requested operation fails (e.g., the service fails to start or reload successfully).<br><br>


title: DESCRIPTION
content:
The <b>systemctl</b> command is the primary tool for controlling the <i>systemd</i> system and service manager. When managing running services, two crucial subcommands are <b>reload</b> and <b>restart</b>, each serving a distinct purpose for applying configuration changes.<br><br>The <b>reload</b> subcommand instructs a service to re-read its configuration files without completely stopping and starting the process. This approach is designed to be less disruptive, aiming to maintain service availability during configuration updates. However, its effectiveness depends entirely on whether the service's daemon is designed to support graceful reloading. Not all services implement this functionality, or they may only partially support it for certain configuration parameters.<br><br>Conversely, the <b>restart</b> subcommand performs a complete stop and subsequent start of the service. This ensures that the service fully re-initializes and loads all configuration changes from scratch. While more disruptive, causing a brief period of downtime for the service, <b>restart</b> guarantees that all new settings are applied and can resolve issues that a simple reload might miss or cannot handle. It is the go-to command for significant configuration changes or when a service doesn't support reloading.


title: CAVEATS
content:
<b>Service-Dependent Reload:</b> The success and extent of a <b>reload</b> operation are entirely dependent on how the specific service's daemon is coded. Many services may not support it, or only partially.<br><br><b>Disruptive Restart:</b> A <b>restart</b> operation will momentarily stop the service, causing a brief period of unavailability or disruption for users or applications relying on it.<br><br><b>Permissions:</b> Managing system services with <b>systemctl reload</b> or <b>restart</b> typically requires root privileges (e.g., using <b>sudo</b>).<br><br><b>Configuration Errors:</b> Applying new configuration via <b>reload</b> or <b>restart</b> with syntax errors will likely cause the operation to fail, potentially leaving the service in a stopped state if it was a <b>restart</b>.<br><br><b>Persistent Changes:</b> <b>systemctl</b> commands only affect the running state. To make changes persistent across reboots, the configuration files themselves must be edited.


title: WHEN TO USE <B>RELOAD</B>
content:
Use <b>systemctl reload</b> for minor configuration changes that do not fundamentally alter the service's architecture or resource allocation. Examples include updating log rotation settings, changing minor tuning parameters, or adding new virtual hosts to a web server without modifying its core listening ports or modules. Always confirm if the specific service supports a graceful reload for the changes you are applying.


title: WHEN TO USE <B>RESTART</B>
content:
Opt for <b>systemctl restart</b> when applying significant configuration changes (e.g., changing listening ports, enabling/disabling major modules, altering fundamental service behavior), when the service does not support <b>reload</b>, or when a <b>reload</b> does not seem to take effect. It's also the go-to command for troubleshooting an unstable service or applying security patches that require a full service re-initialization.


title: HISTORY
content:
The concepts of reloading and restarting services predate <i>systemd</i>, existing in older init systems like <i>SysVinit</i> and <i>Upstart</i> (e.g., using <b>service apache2 reload</b>). However, <i>systemd</i>, introduced to many Linux distributions as the default init system, standardized these operations under the <b>systemctl</b> command. Its adoption marked a significant shift towards a more unified and powerful service management framework, replacing disparate init scripts with declarative unit files and providing a consistent interface through <b>systemctl</b> for operations like starting, stopping, reloading, and restarting services.


title: TLDR
content:
<b>Reload or restart a unit</b>`systemctl reload-or-restart [unit]`<br><b>Reload or restart multiple units matching a pattern</b>`systemctl reload-or-restart [pattern]`<br><b>Run the command without waiting for the operation to complete</b>`systemctl reload-or-restart [unit] --no-block`<br><b>Apply the command only to user units</b>`systemctl reload-or-restart [unit] --user`


title: PARAMETERS
content:
<b>--no-block</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Do not wait for the requested operation to finish. If an operation is requested that would block, this option makes it return immediately.<br><br><b>--job-mode=MODE</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Controls how new jobs interact with existing pending jobs. Common modes include <b>fail</b> (if a job conflicts, new job fails), <b>replace</b> (replaces conflicting jobs), <b>ignore-dependencies</b> (starts target without pulling in dependencies). Default is usually <b>replace</b>.<br><br><b>-h, --help</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Show a short help text and exit.<br><br><b>--version</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Show a short version string and exit.<br><br><b>--system</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Connect to the systemd system manager. This is the default.<br><br><b>--user</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Connect to the systemd user manager. (Not typically relevant for rescue mode).<br><br><b>--host=HOST</b><br>&nbsp;&nbsp;&nbsp;&nbsp;Operate on a remote host via systemd's D-Bus interface. Requires appropriate setup and authentication.<br><br>


title: DESCRIPTION
content:
The <b>systemctl-rescue</b> command is a convenient shortcut provided by <b>systemd</b> to transition the system into <i>rescue mode</i>. This special operational state is designed for system troubleshooting, maintenance, and recovery when the normal boot process fails or when specific low-level system repairs are required. When invoked, <b>systemctl-rescue</b> effectively executes <b>systemctl isolate rescue.target</b>.<br><br>In rescue mode, <b>systemd</b> attempts to mount all local filesystems but starts only a minimal set of services essential for basic system operation, such as a root shell. Unlike <i>emergency mode</i>, which provides an even more restricted environment (often read-only root), rescue mode typically provides a more functional environment with network capabilities and a login prompt, allowing administrators to log in and perform diagnostics, fix broken configurations, or repair filesystem issues before a full system boot. It's an invaluable tool for recovering systems that fail to boot into a graphical or even standard multi-user environment.


title: CAVEATS
content:
<ul><li><b>Requires root privileges:</b> Changing the system target requires superuser permissions.</li><li><b>Data loss potential:</b> Incorrect commands or operations in rescue mode can lead to data loss or further system instability. Exercise caution.</li><li><b>Limited environment:</b> Not all services or applications will be running. Some tools or configurations might not be available as they would be in a fully booted system.</li><li><b>No guaranteed network:</b> While rescue mode is generally more functional than emergency mode, network interfaces or specific networking services might not be fully operational by default, depending on the distribution and configuration.</li><li><b>Reboot required:</b> After troubleshooting and fixing issues, a system reboot is typically required to return to normal operation.</li></ul>


title: EXITING RESCUE MODE
content:
To exit rescue mode and attempt a normal boot, you can use <b>systemctl default</b> or simply <b>reboot</b>.


title: BOOTING INTO RESCUE MODE DIRECTLY
content:
You can typically instruct the boot loader (GRUB) to boot directly into rescue mode by appending <b>systemd.unit=rescue.target</b> or <b>rescue</b> to the kernel command line during boot.


title: COMPARISON WITH EMERGENCY MODE
content:
<i>Rescue mode</i> (<b>rescue.target</b>) mounts local filesystems and starts essential services, often including a login prompt. <i>Emergency mode</i> (<b>emergency.target</b>) provides an even more minimal environment, often with the root filesystem mounted read-only and no services started, requiring manual mounting and setup. Rescue mode is generally preferred when you need more tools or network access.


title: HISTORY
content:
The <b>systemctl-rescue</b> command is an integral part of <b>systemd</b>, the widely adopted init system and service manager for Linux. <b>systemd</b> was first released in 2010 by Lennart Poettering and Kay Sievers, aiming to provide a more efficient and parallelized boot process compared to traditional System V init scripts. The concept of rescue mode, however, existed prior to <b>systemd</b> in various forms (e.g., <i>single user mode</i>, <i>runlevel 1</i>). <b>systemd</b> standardized this functionality through specific targets like <b>rescue.target</b> and provided <b>systemctl rescue</b> as a direct, intuitive way to activate it. Its usage has grown steadily with the increasing adoption of <b>systemd</b> across major Linux distributions.


title: TLDR
content:
<b>Enter rescue mode</b>`systemctl rescue`<br><b>Enter rescue mode asynchronously</b>`systemctl rescue --no-block`


title: PARAMETERS
content:
<b><i>UNIT</i>...</b><br>&nbsp;&nbsp;&nbsp;&nbsp;One or more names of <b>systemd</b> units (e.g., <i>nginx.service</i>, <i>dbus.socket</i>) whose failed state should be cleared. If no <i>UNIT</i>s are specified, the command will attempt to reset the 'failed' state for all currently failed units across the system.<br><br>


title: DESCRIPTION
content:
The <b>systemctl reset-failed</b> command is a crucial utility within the <b>systemd</b> ecosystem for managing the operational status of units. When a service, socket, mount point, or any other <b>systemd</b> unit encounters an error during startup or operation, <b>systemd</b> marks it with a 'failed' state. This state persists even if you subsequently fix the underlying problem and restart the unit successfully. The primary purpose of <b>reset-failed</b> is to clear this persistent 'failed' status, allowing <b>systemd</b> to accurately reflect the current operational health of your system.<br><br>It <i>does not fix the root cause</i> of the failure; rather, it cleans up the administrative state. You would typically use this command after you have successfully resolved the issue that caused the unit to fail and, optionally, restarted it. Executing <b>systemctl reset-failed</b> will remove the 'failed' flag, ensuring that the unit no longer appears in the list generated by <b>systemctl --failed</b> or in the detailed output of <b>systemctl status</b> as 'failed'. This helps in maintaining a clear and accurate overview of your system's health.


title: CAVEATS
content:
Using <b>reset-failed</b> only clears the <i>status</i> flag; it does not resolve the underlying problem that caused the unit to fail. The unit might immediately fail again if the root cause persists. This command typically requires root privileges (e.g., via <b>sudo</b>) or appropriate Polkit permissions to execute, as it modifies the system's runtime state.


title: WHEN TO USE
content:
This command is best used after you have successfully identified and fixed the problem preventing a <b>systemd</b> unit from running correctly. After fixing the issue and potentially restarting the service (e.g., with <b>systemctl restart <i>UNIT</i></b>), use <b>systemctl reset-failed <i>UNIT</i></b> to clear the lingering 'failed' state and get an accurate status.


title: PERMISSIONS
content:
Due to its nature of modifying system state, <b>systemctl reset-failed</b> usually requires superuser privileges. Users will typically execute it as <b>sudo systemctl reset-failed</b> or as the root user.


title: HISTORY
content:
The <b>reset-failed</b> subcommand is an integral part of <b>systemctl</b>, the main command-line interface for controlling and querying the <b>systemd</b> init system. <b>systemd</b> was initially released in 2010 and has since become the default init system for most major Linux distributions, replacing older systems like <b>SysVinit</b>. As <b>systemd</b> evolved to manage system services and other components, commands like <b>reset-failed</b> were developed to provide granular control over unit states, enabling administrators to maintain accurate system status reporting.


title: SEE ALSO
content:
systemctl(1), systemctl status(1), systemctl --failed(1), systemctl start(1), systemctl restart(1), journalctl(1)


title: TLDR
content:
<b>Reset the failed state of all units</b>`systemctl reset-failed`<br><b>Reset the failed state of a specific unit</b>`systemctl reset-failed [unit]`<br><b>Reset multiple units at once</b>`systemctl reset-failed [unit_1 unit_2 ...]`


title: SYNOPSIS
content:
Since systemctl-service-log-level is a conceptual task rather than a single command, its "synopsis" involves a combination of actions:<br><br><i>To modify a service's log level:</i><br>1. <b>Edit application configuration:</b><br>   <i>(e.g., editing /etc/APP/app.conf to modify internal log settings.)</i><br><br>2. <b>Or, edit the systemd unit file:</b><br>   <b>sudo systemctl edit --full</b> <I>SERVICE_UNIT</I><br>   <i>(Modify the <B>ExecStart=</B> line to pass log level arguments, such as <B>ExecStart=/usr/bin/app --loglevel debug</B>)</i><br><br>3. <b>Apply unit file changes:</b><br>   <b>sudo systemctl daemon-reload</b><br><br>4. <b>Restart the service:</b><br>   <b>sudo systemctl restart</b> <I>SERVICE_UNIT</I><br><br><i>To view a service's logs with a specific priority:</i><br><b>journalctl -u</b> <I>SERVICE_UNIT</I> <b>[-p</b> <I>PRIORITY</I><b>]</b>


title: PARAMETERS
content:
<b><I>SERVICE_UNIT</I></b><br>&nbsp;&nbsp;&nbsp;&nbsp;The name of the systemd service unit (e.g., <I>apache2.service</I>, <I>mywebapp.service</I>) whose log level or logs are being managed.<br><br><b>daemon-reload</b><br>&nbsp;&nbsp;&nbsp;&nbsp;A <B>systemctl</B> subcommand used to reload the systemd manager configuration. This is necessary after modifying service unit files to make systemd aware of the changes.<br><br><b>restart</b><br>&nbsp;&nbsp;&nbsp;&nbsp;A <B>systemctl</B> subcommand used to stop and then start a specified service. Essential for applying configuration changes that affect the service's runtime behavior, including log levels.<br><br><b>-u, --unit</b><br>&nbsp;&nbsp;&nbsp;&nbsp;An option for <B>journalctl</B> to display logs only from the specified systemd unit (service, slice, scope, etc.).<br><br><b>-p, --priority</b><br>&nbsp;&nbsp;&nbsp;&nbsp;An option for <B>journalctl</B> to filter log messages by priority level (e.g., <I>emerg</I>, <I>alert</I>, <I>crit</I>, <I>err</I>, <I>warning</I>, <I>notice</I>, <I>info</I>, <I>debug</I>). It shows messages at or above the specified priority.<br><br><b>edit --full</b><br>&nbsp;&nbsp;&nbsp;&nbsp;A <B>systemctl</B> subcommand used to open the full unit file for editing. It's recommended over direct file editing as it handles overrides correctly and reloads the daemon.<br><br>


title: DESCRIPTION
content:
systemctl-service-log-level is <I>not</I> a standalone Linux command but rather a conceptual operation referring to the process of managing logging verbosity for services running under systemd. In a systemd environment, individual applications (wrapped as systemd services) often control their own internal log levels through their specific configuration files or command-line arguments. <br><br> The <B>systemctl</B> command itself is primarily used for controlling the state of these services (starting, stopping, restarting, enabling, disabling). When changes to a service's log level are desired, this typically involves modifying the application's configuration file or adjusting the <B>ExecStart</B> directive within the service's <I>.service</I> unit file (e.g., adding a <B>--debug</B> or <B>--verbose</B> flag to the application's startup command). After such modifications, <B>systemctl</B> is then used to <B>daemon-reload</B> and <B>restart</B> the affected service to apply the changes. <br><br> For viewing logs, the <B>journalctl</B> command, which interacts with systemd's unified logging system (<I>journald</I>), is used. It allows filtering logs by service unit, time, and even priority, giving insight into the actual log output at various verbosity levels. Therefore, managing a service's log level is a multi-step process often combining editing configuration files, using <B>systemctl</B> for service control, and <B>journalctl</B> for log inspection.


title: CAVEATS
content:
systemctl-service-log-level is <B>not an actual command</B>; it describes a <I>task</I>. Log levels are typically an internal setting of the application itself, not a direct property managed by systemd. Changing log levels usually requires modifying configuration files (either application-specific or the systemd unit file's <B>ExecStart</B> directive) and then restarting the service. Permissions are critical; <B>sudo</B> is often required for modifying systemd unit files and restarting services. Misconfiguring a service unit can prevent the service from starting.


title: UNDERSTANDING LOG LEVELS
content:
Log levels (e.g., DEBUG, INFO, WARNING, ERROR, CRITICAL) are a common concept in software development, indicating the severity or verbosity of a log message. Setting a higher log level (e.g., ERROR) typically reduces log output, showing only critical events, whereas a lower level (e.g., DEBUG) produces very detailed output, useful for troubleshooting.


title: APPLICATION-SPECIFIC CONFIGURATION
content:
Many applications offer their own configuration files (e.g., <I>/etc/apache2/apache2.conf</I> for Apache, <I>php.ini</I> for PHP) where log levels can be directly adjusted. This is often the primary and most flexible way to manage application logging verbosity.


title: UNIT FILE OVERRIDES
content:
Instead of directly editing a package's unit file like <I>/lib/systemd/system/service.service</I>, it's generally recommended to create an override. This can be done with <B>sudo systemctl edit</B> <I>SERVICE_UNIT</I>. This creates an override file (e.g., <I>/etc/systemd/system/service.service.d/override.conf</I>) where you can add or modify specific directives, such as the <I>ExecStart</I> line, without altering the original file provided by the system package. This approach ensures your changes persist across package updates.


title: HISTORY
content:
The introduction of systemd as the primary init system in many Linux distributions brought a unified approach to service management and logging. Before systemd, services often had disparate logging mechanisms (e.g., writing to <I>/var/log/messages</I>, <I>/var/log/syslog</I>, or custom application logs). Systemd's <I>journald</I> daemon standardized log collection, offering a centralized binary log that <B>journalctl</B> can query efficiently. While <I>journald</I> provides filtering capabilities based on log priority, the <I>internal</I> log level of an application remains its own domain. The conceptual "systemctl-service-log-level" task evolved as users sought ways to control the verbosity of application output within this new, unified logging framework, largely relying on application-specific settings exposed through systemd unit files.


title: TLDR
content:
<b>Show the current log level of a service</b>`systemctl service-log-level [service_name]`<br><b>Set the log level of a service (the level name can be replaced with a number from 0 to 7)</b>`systemctl service-log-level [service_name] [emerg|alert|crit|err|warning|notice|info|debug]`


title: TLDR
content:
<b>Display the filesystem label</b>`sudo xfs_admin [[-l|--list]] [/dev/sdX]`<br><b>Set the filesystem label</b>`sudo xfs_admin [[-L|--Label]] "[label]" [/dev/sdX]`<br><b>Display the filesystem UUID</b>`sudo xfs_admin [[-u|--uuid]] [/dev/sdX]`<br><b>Set the filesystem UUID (use with caution)</b>`sudo xfs_admin [[-U|--UUID]] [uuid] [/dev/sdX]`<br><b>Generate a new UUID for the filesystem</b>`sudo xfs_admin [[-U|--UUID]] generate [/dev/sdX]`<br><b>Display help</b>`xfs_admin`


title: TLDR
content:
<b>Start asciiquarium</b>`asciiquarium`<br><b>Pipe the output through lolcat for rainbow colors</b>`asciiquarium | lolcat`<br><b>Toggle [p]ause</b>`<p>`<br><b>[r]edraw aquarium and all entities</b>`<r>`<br><b>Exit asciiquarium</b>`<q>`


title: SYNOPSIS
content:
<i>az cognitiveservices <command> [options]</i><br><br>Common subcommands include:<br><i>az cognitiveservices account <subcommand> [options]</i> (e.g., <i>create, list, show, delete, keys</i>)<br><i>az cognitiveservices deployment <subcommand> [options]</i> (e.g., <i>create, list, show, delete</i>)<br><i>az cognitiveservices commitment-tier <subcommand> [options]</i> (e.g., <i>list, show</i>)


title: PARAMETERS
content:
<b><b>--help -h</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Show help message for the command or subcommand.<br><br><b><b>--output -o</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Output format. Values: <i>json, jsonc, table, tsv, yaml, yamlc, none</i>. Default: <i>json</i>.<br><br><b><b>--query</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;JMESPath query string. See <I>http://jmespath.org/</I> for more information and examples.<br><br><b><b>--verbose</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Increase logging verbosity to show debug logs.<br><br><b><b>--debug</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Increase logging verbosity to show all debug logs.<br><br><b><b>--subscription</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Name or ID of subscription. You can configure the default subscription using <i>az account set -s NAME_OR_ID</i>.<br><br><b><b>--only-show-errors</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Put errors on stderr, and do not show warnings or other information.<br><br><b><b>--yes -y</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Do not prompt for confirmation.<br><br>


title: DESCRIPTION
content:
The <i>az-cognitiveservices</i> command refers to the command group within the Azure Command-Line Interface (CLI) used for managing Azure Cognitive Services. These services provide powerful AI capabilities, such as vision, speech, language, and decision-making, which developers can integrate into their applications.<br><br>The <i>az cognitiveservices</i> command group allows users to programmatically interact with their Cognitive Services resources in Azure. This includes operations like creating, listing, showing details of, updating, and deleting Cognitive Services accounts, managing API keys, and handling resource deployments. It serves as a vital tool for automating resource provisioning, configuration, and management tasks, making it easier to integrate AI capabilities into continuous integration/continuous deployment (CI/CD) pipelines and scripting environments.


title: CAVEATS
content:
<ul><li>Requires the Azure CLI to be installed and configured on the Linux system.</li><li>Users must be authenticated to Azure using <i>az login</i> with appropriate permissions for resource management.</li><li>Understanding of Azure resource groups, subscriptions, and Cognitive Services resource types is essential for effective use.</li><li>API limits and costs are associated with Cognitive Services resources; careful management is advised.</li></ul>


title: COMMON USAGE PATTERN
content:
To create a Cognitive Services account:<br><i>az cognitiveservices account create --name myCognitiveAccount --resource-group myResourceGroup --kind TextAnalytics --sku S0 --location eastus</i>


title: API KEYS MANAGEMENT
content:
After creating an account, you can retrieve its API keys using:<br><i>az cognitiveservices account keys list --name myCognitiveAccount --resource-group myResourceGroup</i>


title: MODEL DEPLOYMENT (E.G., AZURE OPENAI)
content:
For services like Azure OpenAI, deploying a model is crucial:<br><i>az cognitiveservices deployment create --name myDeployment --account-name myOpenAIAccount --resource-group myResourceGroup --model-name gpt-4 --model-version 0613 --model-format OpenAI --sku-name Standard --capacity 1</i>


title: HISTORY
content:
The Azure CLI has evolved significantly since its initial release, with continuous integration of new Azure services. The Cognitive Services command group was introduced as part of this ongoing development, providing native command-line support for managing these AI services. Its usage has grown steadily alongside the increased adoption of Azure Cognitive Services, becoming a standard tool for developers and operations teams seeking to automate and script their AI infrastructure management within Azure.


title: TLDR
content:
<b>Create an API Cognitive Services account in a specific location without confirmation required</b>`az cognitiveservices account create [[-n|--name]] [account_name] [[-g|--resource-group]] [resource_group] --kind [API_name] [[-l|--location]] [location] --sku [sku_name] --yes`<br><b>List usages for Azure Cognitive Services account</b>`az cognitiveservices account list-usage [[-n|--name]] [account_name] [[-g|--resource-group]] [resource_group]`<br><b>Create a deployment for Azure Cognitive Services account</b>`az cognitiveservices account deployment create [[-n|--name]] [account_name] [[-g|--resource-group]] [resource_group] --deployment-name [deploy_name] --model-name [model_name] --model-version "[model_version]" --model-format [format_name]`<br><b>Create a commitment plan for Azure Cognitive Services account</b>`az cognitiveservices account commitment-plan create [[-n|--name]] [account_name] [[-g|--resource-group]] [resource_group] --commitment-plan-name "[plan_name]" --hosting-model "[hosting_model]" --plan-type "[plan_type]" --auto-renew [false|true]`<br><b>Delete a commitment plan from Azure Cognitive Services account</b>`az cognitiveservices account commitment-plan delete [[-g|--resource-group]] [resource_group] [[-n|--name]] [account_name] --commitment-plan-name "[plan_name]"`


title: PARAMETERS
content:
<b><b>--dev</b>, <b>-d</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Adds the specified packages to the <I>devDependencies</I> section of <I>package.json</I>.<br><br><b><b>--exact</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Installs and saves the package with an exact version number, preventing future automatic updates to minor or patch versions (e.g., <I>lodash@1.2.3</I> instead of <I>^1.2.3</I>).<br><br><b><b>--filter</b> <i>&lt;pattern&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;In a monorepo setup, adds packages to specific workspaces whose names match the provided pattern.<br><br><b><b>--global</b>, <b>-g</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Installs the package globally on the system, making its executables available in the system's PATH. Global packages are not tied to a specific project's dependencies.<br><br><b><b>--no-save</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Installs the package but does not add it to the <I>dependencies</I> (or any other dependency type) section in <I>package.json</I>.<br><br><b><b>--optional</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Adds the specified packages to the <I>optionalDependencies</I> section of <I>package.json</I>. These packages are not critical for the application's functionality and may fail to install without stopping the entire process.<br><br><b><b>--peer</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Adds the specified packages to the <I>peerDependencies</I> section of <I>package.json</I>. Peer dependencies are typically required by a plugin or library to specify compatible versions of dependencies that their host project should already have.<br><br><b><b>--workspace</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;When run within a workspace in a monorepo, this flag adds the package to the root workspace's <I>package.json</I> instead of the current sub-workspace.<br><br>


title: DESCRIPTION
content:
<i>bun add</i> is a subcommand of the <I>Bun JavaScript runtime</I> and package manager. It is used to install and add new packages as dependencies to a JavaScript or TypeScript project, similar to how <i>npm install</i> or <i>yarn add</i> function. When executed, it downloads the specified packages, updates the project's <I>package.json</I> file with the new dependency entries, and updates the <I>bun.lockb</I> lockfile to ensure reproducible installations. It supports adding various types of dependencies, including regular dependencies, development dependencies, optional dependencies, and peer dependencies, by using specific flags. <I>bun add</I> is a core part of Bun's integrated toolchain, offering a fast and efficient way to manage project dependencies.


title: CAVEATS
content:
<b>bun add</b> is specifically designed for JavaScript/TypeScript project dependency management and requires the <I>Bun runtime</I> to be installed on your system. It is not a system package manager (like <i>apt</i>, <i>yum</i>, or <i>dnf</i>) and does not manage system-level software. The lockfile (<I>bun.lockb</I>) is Bun-specific and not compatible with other package managers like npm or Yarn's lockfiles.


title: VERSION SPECIFIERS
content:
Packages can be added with specific version requirements, such as <I>bun add lodash@^4.17.21</I> (caret range), <I>bun add express@~4.0.0</I> (tilde range), <I>bun add react@18.2.0</I> (exact version), or <I>bun add webpack@latest</I> (latest available). You can also specify packages from local paths (<I>file:../my-package</I>) or Git repositories.


title: MULTIPLE PACKAGES
content:
You can add multiple packages in a single command, for example: <I>bun add react react-dom axios</I>. All specified packages will be added according to the flags provided.


title: HISTORY
content:
Bun is a relatively new JavaScript runtime and toolkit, created by Jarred Sumner, with its initial public release in 2022. It was developed from the ground up to offer significantly faster performance than existing JavaScript runtimes and package managers. <b>bun add</b> is an integral part of Bun's integrated package manager, aiming to provide a high-performance alternative to traditional tools like npm and Yarn for managing project dependencies. Its development focuses on speed, simplicity, and an all-in-one developer experience.


title: TLDR
content:
<b>Install a single package</b>`bun add [package]`<br><b>Install multiple packages</b>`bun add [package1 package2 ...]`<br><b>Install from a Git repository</b>`bun add [git_url]`<br><b>Install a specific version</b>`bun add [package]@[version]`<br><b>Install from local file or directory</b>`bun add file:[path/to/file_or_directory]`<br><b>Add a dev dependency</b>`bun add [[-d|--dev]] [package]`<br><b>Add a package globally</b>`bun add [[-g|--global]] [package]`


title: PARAMETERS
content:
<b><i>No direct parameters</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;The <b>bun feedback</b> command itself does not accept any specific options or arguments. It simply triggers the opening of the feedback form in a web browser.<br><br>


title: DESCRIPTION
content:
The <b>bun feedback</b> command is a convenient utility within the Bun JavaScript runtime's command-line interface, designed to facilitate direct communication between users and the Bun development team.<br><br>When invoked, this command automatically launches the user's default web browser and navigates to the official Bun feedback form. This form typically allows users to report bugs, suggest new features, share general impressions, or provide insights into their experience with Bun. Its primary purpose is to streamline the process of gathering community input, which is crucial for identifying areas of improvement, prioritizing development efforts, and fostering a robust and user-centric runtime.<br><br>By integrating this feedback mechanism directly into the CLI, Bun encourages its users to actively participate in its development lifecycle, making it easier to contribute valuable data without manually searching for the appropriate channel.


title: CAVEATS
content:
Using <b>bun feedback</b> requires an active internet connection to access the online feedback form. Additionally, it relies on a graphical desktop environment with a configured default web browser to function as intended. In a headless server environment or systems without a browser, the command will execute but might fail to open the URL, or the URL might need to be manually copied and opened on another device.


title: USAGE SCENARIO
content:
After encountering an unexpected error while bundling a project, a developer can quickly run <b>bun feedback</b> to report the bug without leaving their terminal. Similarly, if a user has an idea for a performance optimization or a new CLI feature, this command provides an immediate channel to submit that suggestion to the Bun team.


title: BROWSER INTEGRATION
content:
The command typically uses the system's default program for opening URLs. On most Linux distributions with a desktop environment, this means it will launch Firefox, Chromium, or another installed browser. The exact behavior can sometimes be influenced by environment variables like <b>BROWSER</b>.


title: HISTORY
content:
The <b>bun feedback</b> command, like much of the Bun CLI, is a relatively recent addition to the Linux command landscape, emerging with the rapid development and growing popularity of the Bun JavaScript runtime. Bun itself was publicly launched in 2022 by Jarred Sumner, with a strong emphasis on speed, developer experience, and community engagement. The inclusion of a direct feedback mechanism highlights Bun's commitment to iterative development, where user input plays a vital role in shaping the project's direction and addressing pain points from early adopters. This command was designed to make the feedback loop as seamless as possible, reflecting a modern approach to open-source project development.


title: TLDR
content:
<b>Send text as feedback</b>`bun feedback "[Feedback text!]"`<br><b>Send one or more files as feedback</b>`bun feedback [path/to/file1 path/to/file2 ...]`<br><b>Send feedback with email address attached</b>`bun feedback [path/to/file|text] [[-e|--email]] [email@address]`


title: SYNOPSIS
content:
<b>bunx</b> [<i>options</i>] <i>&lt;command&gt;</i> [<i>args...</i>]<br><b>bunx</b> [<i>options</i>] <i>&lt;package&gt;@&lt;version&gt;</i> [<i>args...</i>]


title: PARAMETERS
content:
<b><i>&lt;command&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;The name of the executable from an npm package to run. <i>bunx</i> will locate it in <i>node_modules</i> or fetch it.<br><br><b><i>&lt;package&gt;@&lt;version&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specifies a package name and an optional version (e.g., <i>cowsay@1.5.0</i>) to fetch and execute. If no version is specified, the latest stable version is used.<br><br><b><i>[args...]</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Any additional arguments to be passed directly to the invoked executable.<br><br><b><b>-h</b>, <b>--help</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Displays the help message for the <i>bunx</i> command itself.<br><br><b><b>--cwd</b> <i>&lt;dir&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specifies the current working directory for the command execution.<br><br>


title: DESCRIPTION
content:
<i>bunx</i> is the Bun runtime's equivalent of <i>npx</i> in Node.js. It allows developers to execute binaries from npm packages without requiring them to be globally installed. When invoked, <i>bunx</i> first checks if the specified executable is available in the local <i>node_modules</i> directory. If not found, it efficiently downloads the necessary package to a temporary directory, executes the command, and then cleans up. This functionality is invaluable for one-off commands, scaffolding tools (like <i>create-react-app</i>), or running development utilities without cluttering global package installations. It leverages Bun's performance advantages, offering significantly faster execution compared to traditional methods. <i>bunx</i> streamlines development workflows by making it easy to access and run package-specific commands on demand.


title: CAVEATS
content:
<i>bunx</i> requires the <B>Bun runtime</B> to be installed on your system. While it aims for npm compatibility, there might be edge cases or specific package features that behave differently compared to <i>npx</i> or <i>npm</i> due to Bun's distinct implementation. Always exercise caution when executing commands from untrusted packages, as <i>bunx</i> will download and run code from the internet.


title: USAGE EXAMPLES
content:
Execute a package command:<br><i>bunx cowsay &quot;Hello Bun!&quot;</i><br><br>Scaffold a new project:<br><i>bunx create-react-app my-app</i><br><br>Run a specific version of a package:<br><i>bunx eslint@8.0.0 --init</i>


title: COMPARISON WITH NPX
content:
Both <i>bunx</i> and <i>npx</i> serve the same purpose: running npm package executables without global installation. The primary difference lies in their underlying runtime: <i>bunx</i> uses the <B>Bun runtime</B> (written in Zig), while <i>npx</i> uses <B>Node.js</B>. This often gives <i>bunx</i> a notable performance advantage in terms of execution speed and startup time.


title: COMPARISON WITH BUN RUN
content:
While related, <i>bunx</i> and <i>bun run</i> have distinct uses.<br><br><b><i>bunx</i></b>: Executes package binaries (e.g., <i>cowsay</i>, <i>create-react-app</i>) either locally or by fetching them.<br><br><b><i>bun run</i></b>: Executes scripts defined in the <i>&quot;scripts&quot;</i> section of your project's <i>package.json</i> file (e.g., <i>bun run start</i>, <i>bun run test</i>).


title: HISTORY
content:
<i>bunx</i> was introduced as an integral part of the <B>Bun JavaScript runtime</B>, which was created by <B>Jarred Sumner</B> and publicly launched in 2022. Bun's ambitious goal is to be an all-in-one toolkit for JavaScript and TypeScript development, encompassing a runtime, package manager, and bundler. <i>bunx</i> specifically emerged as Bun's answer to Node.js's <i>npx</i>, aiming to provide a significantly faster and more efficient way to execute package binaries. Its development reflects Bun's core philosophy of speed and consolidation within the JavaScript ecosystem.


title: TLDR
content:
<b>Download and execute a package from the registry</b>`bunx [package_name] "[command_argument]"`<br><b>Check the version of a locally installed package (if found)</b>`bunx [package_name] --version`<br><b>Force an executable to run with the Bun runtime (instead of Node)</b>`bunx --bun [package_name]`<br><b>Execute a binary that has a different name than its package</b>`bunx [[-p|--package]] [package_name] [command]`<br><b>Download and execute a specific version of a package</b>`bunx [package_name@version] "[command_argument]"`


title: SYNOPSIS
content:
<b>chdman</b> <i>&lt;command&gt;</i> [<i>&lt;options&gt;</i>] [<i>&lt;arguments&gt;</i>]<br><br>Example Usage:<br><b>chdman</b> createhd -i <i>input.raw</i> -o <i>output.chd</i> -c zlib<br><b>chdman</b> info -i <i>game.chd</i><br><b>chdman</b> verify -i <i>game.chd</i>


title: PARAMETERS
content:
<b><b>createhd</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Creates a new hard disk image in the CHD format from a raw disk image file. Supports various compression methods.<br><br><b><b>createcd</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Creates a new CD-ROM image in the CHD format from a CUE/BIN or similar CD image set, or directly from an optical drive.<br><br><b><b>createld</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Creates a new LaserDisc image in the CHD format from raw video and audio streams, typically for specific LaserDisc formats.<br><br><b><b>extractraw</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Extracts the raw uncompressed data from an existing CHD file back into a raw disk image, CUE/BIN, or other raw format.<br><br><b><b>verify</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Checks the integrity of an existing CHD file, ensuring all hunks are correct and not corrupted by comparing against stored checksums.<br><br><b><b>info</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Displays detailed information about a CHD file, including its format version, size, compression details, internal structure, and checksums.<br><br><b><b>convert</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Converts an existing CHD file, potentially changing its compression algorithm, hunk size, or CHD format version (e.g., from v3 to v5).<br><br><b><b>-i</b> <i>&lt;inputfile&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specifies the input file for the operation (e.g., a raw disk image, a CUE file, or an existing CHD). This is mandatory for most commands.<br><br><b><b>-o</b> <i>&lt;outputfile&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specifies the output file for the operation (e.g., the new CHD file or the extracted raw data). This is mandatory for commands like <b>createhd</b>, <b>createcd</b>, <b>createld</b>, <b>extractraw</b>, and <b>convert</b>.<br><br><b><b>-c</b> <i>&lt;algorithm&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Sets the compression algorithm to use when creating or converting a CHD. Common algorithms include <i>zlib</i>, <i>lzma</i>, <i>huffman</i>, <i>flac</i>, <i>cd-rom</i>, and <i>cd-xa</i>.<br><br><b><b>-h</b> <i>&lt;size&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Specifies the hunk size in bytes for the CHD file. This affects compression efficiency and access patterns. Applicable to <b>createhd</b> and <b>convert</b>.<br><br><b><b>-j</b> <i>&lt;level&gt;</i></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Sets the compression level, typically from 1 (fastest, lowest compression) to 9 (slowest, best compression). Applicable to algorithms like <i>zlib</i> or <i>lzma</i>.<br><br><b><b>-f</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Forces the operation to overwrite an existing output file without prompting for confirmation.<br><br><b><b>-v</b></b><br>&nbsp;&nbsp;&nbsp;&nbsp;Displays verbose output, showing more details about the command's progress and actions.<br><br>


title: DESCRIPTION
content:
<i>chdman</i> is a command-line utility for creating, verifying, and manipulating CHD (Compressed Hunks of Data) files. CHD is a specialized disk image format primarily used by the MAME (Multiple Arcade Machine Emulator) project to store large media like hard drives, CD-ROMs, and LaserDiscs efficiently. It employs various compression algorithms to reduce file sizes, making it practical to store and emulate systems that originally used significant storage.<br><br>The tool allows users to convert raw disk images into the CHD format, extract raw data from existing CHDs, verify the integrity of CHD files, and display detailed information about their structure and content. It's an indispensable component for MAME enthusiasts and preservationists dealing with emulated systems that rely on large, complex storage media.


title: CAVEATS
content:
CHD files come in different versions (v3, v4, v5), and older MAME versions might not support newer CHD formats. Creating or converting very large CHD files can be a time-consuming and resource-intensive process, potentially requiring significant CPU and disk I/O. The choice of compression algorithm impacts both file size and emulation performance; a highly compressed CHD might require more CPU cycles during emulation. Ensuring the source data is correct and complete before CHD creation is crucial, as errors will propagate into the CHD file.


title: COMPRESSION ALGORITHMS
content:
<i>chdman</i> supports various compression algorithms, each suited for different types of data:<br><b>zlib</b>: General-purpose lossless compression, good for most data.<br><b>lzma</b>: Offers higher compression ratios than zlib, but is significantly slower.<br><b>huffman</b>: Used for specific data patterns, often combined with other methods.<br><b>flac</b>: Optimized for lossless audio compression, ideal for audio tracks.<br><b>cd-rom</b>: Specialized for raw CD-ROM data, providing excellent compression for typical CD-ROM layouts.<br><b>cd-xa</b>: Specifically designed for CD-ROM XA (Extended Architecture) data tracks, which have a different structure than standard CD-ROM tracks.


title: CHD FORMAT VERSIONS
content:
The CHD format has evolved over time, with each version introducing new features or compression capabilities:<br><b>v3</b>: An older version, still supported but generally less efficient in compression and features compared to newer versions.<br><b>v4</b>: Introduced better compression, checksumming, and support for features like metadata, becoming widely used.<br><b>v5</b>: The current standard, offering the best compression, robust checksumming, and advanced features. It is highly recommended for new CHDs and provides the most future-proof compatibility with MAME.


title: HISTORY
content:
The CHD (Compressed Hunks of Data) format and its associated utility, <i>chdman</i>, were developed as an integral part of the MAME project to address the growing need to store and emulate systems utilizing large disk media. As MAME expanded to cover arcade games and systems that relied on hard drives, CD-ROMs, and LaserDiscs, a robust and efficient storage solution was necessary to manage gigabytes of data. <i>chdman</i> was introduced to compress these large media images, reducing storage requirements and improving load times during emulation. Over its development, the CHD format evolved through several versions (v3, v4, v5), each bringing improvements in compression algorithms, integrity checking, and feature sets, solidifying <i>chdman</i>'s role as an essential tool for MAME ROM management and digital preservation.


