### Start Jenkins with Custom Settings

Source: https://context7.com/jenkins-zh/jenkins-cli/llms.txt

Demonstrates how to start a Jenkins instance using the jcli command with custom port, version, setup wizard, Docker image, and environment variables.

```bash
jcli center start \
  --port 8080 \
  --version 2.346.3 \
  --setup-wizard=false \
  --image jenkins/jenkins:lts \
  --env JAVA_OPTS="-Xmx2048m"
```

--------------------------------

### Download jcli using Docker (Linux)

Source: https://github.com/jenkins-zh/jenkins-cli/blob/master/docs/book/en/download.md

This example shows how to create a Docker container from the jenkinszh/jcli image, copy the jcli binary to the host system, and then remove the container. Requires Docker to be installed and running.

```shell
jcli_id=$(docker create jenkinszh/jcli) && sudo docker cp $jcli_id:/usr/local/bin/jcli /usr/local/bin/jcli && docker rm -v $jcli_id
```

--------------------------------

### Install Development Tools

Source: https://github.com/jenkins-zh/jenkins-cli/blob/master/CONTRIBUTING.md

Executes the `make tools` command to install necessary development tools for the project. This command ensures that all required dependencies for development are available.

```bash
make tools
```

--------------------------------

### Install Jenkins CLI Plugins

Source: https://github.com/jenkins-zh/jenkins-cli/blob/master/README.md

Demonstrates how to fetch available plugins and install a specific plugin (e.g., 'account') for the Jenkins CLI tool. This extends the functionality of jcli.

```text
jcli config plugin fetch
jcli config plugin install account
```

--------------------------------

### Manage Jenkins Plugins with Go Client

Source: https://context7.com/jenkins-zh/jenkins-cli/llms.txt

This Go code snippet demonstrates how to manage Jenkins plugins using the Jenkins CLI Go client library. It covers retrieving installed plugins and installing new ones. Ensure you have the Jenkins CLI Go client library installed.

```go
// Plugin management via Go client
package main

import (
    "fmt"
    "github.com/jenkins-zh/jenkins-cli/client"
)

func main() {
    pluginMgr := &client.PluginManager{
        JenkinsCore: client.JenkinsCore{
            URL:      "http://localhost:8080",
            UserName: "admin",
            Token:    "your-token",
        },
        UseMirror:    true,
        ShowProgress: true,
        MirrorURL:    "https://mirrors.tuna.tsinghua.edu.cn/jenkins/",
    }

    // Get installed plugins
    plugins, err := pluginMgr.GetPlugins(1)
    if err != nil {
        panic(err)
    }

    for _, plugin := range plugins.Plugins {
        fmt.Printf("%s v%s (Update: %v)\n",
            plugin.ShortName, plugin.Version, plugin.HasUpdate)
    }

    // Install plugins
    err = pluginMgr.InstallPlugin([]string{"git", "pipeline-model-definition"})
    if err != nil {
        panic(err)
    }
}
```

--------------------------------

### Download jcli Development Version (macOS)

Source: https://github.com/jenkins-zh/jenkins-cli/blob/master/docs/book/en/download.md

This example demonstrates how to download the development version of jcli for macOS using a Docker container. It requires Docker to be installed and running.

```shell
jcli_id=$(docker create jenkinszh/jcli:dev) && sudo docker cp $jcli_id:/bin/darwin/jcli . && docker rm -v $jcli_id
```

--------------------------------

### Build Jenkins Job with Parameters

Source: https://github.com/jenkins-zh/jenkins-cli/blob/master/client/doc/README.md

An example function demonstrating how to trigger a Jenkins job with specific parameters using the `jenkins-cli` client. It shows how to define and pass parameter values for 'BRANCH_TAG', 'ENV', and 'DEPLOY_TYPE' when building a job.

```Go
type JobBuildOptions struct {
	Env       string 
	JobName   string 
	BranchTag string 
}


func BuildJob(jobBuild JobBuildOptions) (e error) {
	core, e := GetJenkinsCore()
	jobClient = client.JobClient{core}
	if e != nil {
		return
	}
	param1 := client.ParameterDefinition{
		Description:           "pre and prd please use tag",
		Name:                  "BRANCH_TAG",
		Type:                  "Branch or Tag",
		Value:                 jobBuild.BranchTag,
		DefaultParameterValue: client.DefaultParameterValue{Value: "origin/master"},
	}
	param2 := client.ParameterDefinition{
		Description:           "choice",
		Name:                  "ENV",
		Type:                  "Choice Parameter",
		Value:                 jobBuild.Env,
		DefaultParameterValue: client.DefaultParameterValue{Value: "qa"},
	}
	param3 := client.ParameterDefinition{
		Description:           "Deploy Type",
		Name:                  "DEPLOY_TYPE",
		Type:                  "Choice Parameter",
		Value:                 "publish",
		DefaultParameterValue: client.DefaultParameterValue{Value: "publish"},
	}
	params := []client.ParameterDefinition{param1, param2, param3}
	e = jobClient.BuildWithParams(jobBuild.JobName, params)
	return
}
```

--------------------------------

### Install Jenkins CLI on Windows using Scoop

Source: https://github.com/jenkins-zh/jenkins-cli/blob/master/README.md

Installs the Jenkins CLI tool on Windows using the Scoop package manager. Scoop is a command-line installer for Windows applications.

```text
scoop install jcli
```

--------------------------------

### Install jcli via APT Package Manager (Debian/Ubuntu)

Source: https://github.com/jenkins-zh/jenkins-cli/blob/master/docs/book/en/download.md

This snippet demonstrates how to add the Jenkins CLI APT repository for Debian-based systems and install jcli. It requires sudo privileges and apt-get.

```shell
echo "deb [trusted=yes] https://dl.bintray.com/jenkins-zh/deb wheezy main" | sudo tee -a /etc/apt/sources.list
sudo apt update
```

--------------------------------

### Install jcli via YUM Package Manager

Source: https://github.com/jenkins-zh/jenkins-cli/blob/master/docs/book/en/download.md

This section details how to add the Jenkins CLI YUM repository and install jcli. It involves creating a repository configuration file and then using yum to install the package. Requires sudo privileges.

```shell
cat > bintray-jenkins-zh-rpm.repo <<EOF
#bintraybintray-jenkins-zh-rpm - packages by jenkins-zh from Bintray
[bintraybintray-jenkins-zh-rpm]
name=bintray-jenkins-zh-rpm
baseurl=https://dl.bintray.com/jenkins-zh/rpm
gpgcheck=0
repo_gpgcheck=0
enabled=1
EOF
sudo mv bintray-jenkins-zh-rpm.repo /etc/yum.repos.d/
sudo yum update
```

--------------------------------

### Jenkins CLI Configuration File Example

Source: https://context7.com/jenkins-zh/jenkins-cli/llms.txt

An example YAML structure for the Jenkins CLI configuration file (`~/.jenkins-cli.yaml`). It defines the current Jenkins server, language settings, and a list of multiple Jenkins server profiles, including proxy configurations.

```yaml
# ~/.jenkins-cli.yaml configuration example
current: development
language: en
jenkins_servers:
  - name: development
    url: http://localhost:8080
    username: admin
    token: 11234567890abcdef
    insecureSkipVerify: true
  - name: staging
    url: https://jenkins-staging.example.com
    username: deploy-user
    token: staging-token-here
    proxy: http://proxy.corp.com:8080
    proxyAuth: user:password
  - name: production
    url: https://jenkins.prod.example.com
    username: deploy-user
    token: prod-token-here
```

--------------------------------

### Build Jenkins Job via RESTful API (Go)

Source: https://context7.com/jenkins-zh/jenkins-cli/llms.txt

An example in Go demonstrating how to use the Jenkins CLI client library to perform an advanced job build operation, including identity tracking and returning build details.

```go
// Advanced job build with identity tracking
package main

import (
    "fmt"
    "github.com/jenkins-zh/jenkins-cli/client"
)

func main() {
    jobClient := &client.JobClient{
        JenkinsCore: client.JenkinsCore{
            URL:      "http://localhost:8080",
            UserName: "admin",
            Token:    "your-token",
        },
    }

    // Build and return with tracking
    build, err := jobClient.BuildAndReturn(
        "my-pipeline",
        "Triggered by automation",
        300,  // timeout
        0,    // delay
    )

    if err != nil {
        panic(err)
    }

    fmt.Printf("Build UUID: %s\n", build.Cause.UUID)
    fmt.Printf("Build Number: %d\n", build.Build.Number)
    fmt.Printf("Description: %s\n", build.Cause.ShortDescription)
}
```

--------------------------------

### Generate Jenkins CLI Configuration Programmatically (Go)

Source: https://context7.com/jenkins-zh/jenkins-cli/llms.txt

Demonstrates how to programmatically generate Jenkins CLI configuration data using Go. This involves calling a function to get sample configuration, unmarshalling it from YAML, and accessing its properties.

```go
// Generate sample config programmatically
package main

import (
    "fmt"
    "github.com/jenkins-zh/jenkins-cli/app/cmd"
    "gopkg.in/yaml.v2"
)

func main() {
    // Generate config data
    data, err := cmd.GenerateSampleConfig()
    if err != nil {
        panic(err)
    }

    // Parse and use config
    var config Config
    yaml.Unmarshal(data, &config)
    fmt.Printf("Default server: %s\n", config.Current)
}
```

--------------------------------

### Install Jenkins CLI on macOS using Homebrew

Source: https://github.com/jenkins-zh/jenkins-cli/blob/master/README.md

Installs the Jenkins CLI tool on macOS by adding the official jenkins-zh/jcli tap and then installing the jcli package. This method is straightforward for users who have Homebrew installed.

```text
brew tap jenkins-zh/jcli
brew install jcli
```

--------------------------------

### Manage Jenkins Plugins with jcli

Source: https://context7.com/jenkins-zh/jenkins-cli/llms.txt

Commands for managing Jenkins plugins. Includes functionality to list all plugins, filter by update status, search for available plugins, install (specific versions or multiple), upgrade, uninstall, and check for updates. Supports installation from Jenkins formulas.

```bash
# List all installed plugins
jcli plugin list

# Filter plugins with updates available
jcli plugin list --filter HasUpdate=true

# Search for available plugins
jcli plugin search github

# Install a plugin (latest version)
jcli plugin install git

# Install specific plugin version
jcli plugin install git@4.11.5

# Install multiple plugins
jcli plugin install git github pipeline-model-definition

# Upgrade a plugin
jcli plugin upgrade git

# Uninstall a plugin
jcli plugin uninstall old-plugin

# Check for plugin updates
jcli plugin check

# Install plugins from Jenkins formula
jcli plugin install --formula formula.yaml
```

--------------------------------

### Install Jenkins CLI on Linux using Snap

Source: https://github.com/jenkins-zh/jenkins-cli/blob/master/README.md

Installs, refreshes, and removes the Jenkins CLI tool on Linux using the Snap package manager. Snaps are containerized software packages designed for ease of use and security.

```text
Install:
snap install jcli

Refresh:
snap refresh jcli

Remove:
snap remove jcli
```

--------------------------------

### Manage Jenkins Instances with Docker using jcli Center

Source: https://context7.com/jenkins-zh/jenkins-cli/llms.txt

This section outlines Jenkins Center operations using jcli, focusing on managing Jenkins instances with Docker. Commands include starting Jenkins, downloading WAR files, upgrading, watching logs, logging in, setting mirrors, and listing versions.

```bash
# Start Jenkins using Docker
jcli center start --port 8080 --version 2.346.3

# Download Jenkins WAR file
jcli center download --version 2.346.3

# Upgrade Jenkins
jcli center upgrade

# Watch Jenkins startup logs
jcli center watch

# Login to Jenkins (get token)
jcli center login

# Set Jenkins mirror for downloads
jcli center mirror --name tsinghua

# List available Jenkins versions
jcli center list
```

--------------------------------

### Install Jenkins CLI on Linux

Source: https://github.com/jenkins-zh/jenkins-cli/blob/master/README.md

Installs the Jenkins CLI tool on Linux by downloading the pre-compiled binary for amd64 architecture, extracting it, and moving it to a directory in the system's PATH. This is a common method for Linux distributions.

```sh
curl -L https://github.com/jenkins-zh/jenkins-cli/releases/latest/download/jcli-linux-amd64.tar.gz|tar xzv
sudo mv jcli /usr/local/bin/
```

--------------------------------

### Install Jenkins CLI on macOS using MacPorts

Source: https://github.com/jenkins-zh/jenkins-cli/blob/master/README.md

Installs the Jenkins CLI tool on macOS using the MacPorts package manager. It also shows how to enable shell completion for bash or zsh by adding specific variants during installation.

```text
sudo port install jenkins-cli
# For shell completion:
sudo port install jenkins-cli +bash_completion
sudo port install jenkins-cli +zsh_completion
```

--------------------------------

### Download jcli using cURL (Bintray)

Source: https://github.com/jenkins-zh/jenkins-cli/blob/master/docs/book/en/download.md

This snippet shows how to download a specific version of the jcli binary from JFrog Bintray using cURL and extract it using tar. It requires cURL to be installed.

```shell
curl -L "https://bintray.com/jenkins-zh/jenkins-cli/download_file?file_path=v0.0.24%2Fjcli-darwin-amd64.tar.gz"|tar xzv
```

--------------------------------

### Install Zsh Auto-completion for Jenkins CLI (Shell)

Source: https://github.com/jenkins-zh/jenkins-cli/blob/master/docs/book/en/completion.md

This code block provides shell commands to install the 'incr' plugin for zsh auto-completion. It includes navigating to the oh-my-zsh plugins directory, downloading the plugin, setting execute permissions, and sourcing the plugin in the .zshrc file.

```shell
# cd ~/.oh-my-zsh/plugins
// create incr folder
# mkdir incr
// download incr plugin
# wget https://mimosa-pudica.net/src/incr-0.2.zsh
// authorize incr 
# chmod 777 ~/.oh-my-zsh/plugins/incr/incr-0.2.zsh
# vim ~/.zshrc, and insert "source ~/.oh-my-zsh/plugins/incr/incr-0.2.zsh" in the "~/.zshrc"，save and quit
// flush configuration
# source ~/.zshrc
```

--------------------------------

### Install Jenkins CLI on Windows using Chocolatey

Source: https://github.com/jenkins-zh/jenkins-cli/blob/master/README.md

Installs and upgrades the Jenkins CLI tool on Windows using the Chocolatey package manager. It also provides the command for uninstalling the tool.

```text
Install:
choco install jcli

Upgrade:
choco upgrade jcli

Uninstall:
choco uninstall jcli
```

--------------------------------

### Download jcli Development Version (Linux)

Source: https://github.com/jenkins-zh/jenkins-cli/blob/master/docs/book/en/download.md

This snippet illustrates downloading the development version of jcli for Linux from a Docker image. It creates a temporary container, copies the binary, and removes the container. Requires Docker.

```shell
jcli_id=$(docker create jenkinszh/jcli:dev) && sudo docker cp $jcli_id:/bin/linux/jcli . && docker rm -v $jcli_id
```

--------------------------------

### Download jcli Development Version (Windows)

Source: https://github.com/jenkins-zh/jenkins-cli/blob/master/docs/book/en/download.md

This snippet shows how to obtain the development version of jcli for Windows by copying the executable from a Docker container. Requires Docker.

```shell
jcli_id=$(docker create jenkinszh/jcli:dev) && sudo docker cp $jcli_id:/bin/windows/jcli.exe . && docker rm -v $jcli_id
```

--------------------------------

### Configure Go Module Proxy

Source: https://github.com/jenkins-zh/jenkins-cli/blob/master/CONTRIBUTING.md

Sets the Go module proxy to accelerate dependency downloads. This is a crucial step for ensuring efficient build processes in the Golang environment.

```bash
export GOPROXY=https://mirrors.aliyun.com/goproxy/
```

--------------------------------

### Jenkins Job API Operations

Source: https://github.com/jenkins-zh/jenkins-cli/blob/master/client/doc/README.md

Provides a collection of function signatures for interacting with Jenkins jobs. These include retrieving build information, triggering builds (with and without parameters), fetching build history, and getting job logs. These functions are part of the `JobClient`.

```Go
// GetBuild get build information of a job
func (q *JobClient) GetBuild(jobName string, id int) (job *JobBuild, err error){...}

// Build trigger a job
func (q *JobClient) Build(jobName string) (err error) {...}

// BuildWithParams build a job which has params
func (q *JobClient) BuildWithParams(jobName string, parameters []ParameterDefinition) (err error) {...}

// GetHistory returns the build history of a job
func (q *JobClient) GetHistory(name string) (builds []*JobBuild, err error) {...}

// Log get the log of a job
func (q *JobClient) Log(jobName string, history int, start int64) (jobLog JobLog, err error){...}
```

--------------------------------

### Open Jenkins in Browser with jcli

Source: https://context7.com/jenkins-zh/jenkins-cli/llms.txt

This section details how to open Jenkins instances in a web browser using the Jenkins CLI (jcli). It covers opening the default instance, specific instances, configuration pages, and using custom browser settings or external data URLs.

```bash
# Open default Jenkins in browser
jcli open

# Open specific Jenkins instance
jcli open staging

# Open Jenkins configuration page
jcli open --config

# Open with specific browser
jcli open --browser "Google-Chrome"
export JCLI_BROWSER="Firefox"
jcli open

# Open external data URL (custom shortcuts)
jcli open production.grafana
```

--------------------------------

### Manage Jenkins Jobs with Go Client

Source: https://context7.com/jenkins-zh/jenkins-cli/llms.txt

This Go code snippet demonstrates how to manage Jenkins jobs using the Jenkins CLI Go client library. It covers searching for jobs, building jobs with parameters, and retrieving build information. Requires the Jenkins CLI Go client library.

```go
// Job operations via Go client
package main

import (
    "fmt"
    "time"
    "github.com/jenkins-zh/jenkins-cli/client"
)

func main() {
    jobClient := &client.JobClient{
        JenkinsCore: client.JenkinsCore{
            URL:      "http://localhost:8080",
            UserName: "admin",
            Token:    "your-token",
            Timeout:  60 * time.Second,
        },
    }

    // Search for jobs
    jobs, err := jobClient.Search("deploy", "", 0, 10)
    if err != nil {
        panic(err)
    }

    for _, job := range jobs {
        fmt.Printf("Job: %s\n", job.Name)
    }

    // Build a job with parameters
    params := []client.ParameterDefinition{
        {
            Name:  "version",
            Value: "1.2.3",
            Type:  client.StringParameterDefinition,
        },
        {
            Name:  "environment",
            Value: "production",
            Type:  client.StringParameterDefinition,
        },
    }

    err = jobClient.BuildWithParams("deploy-app", params)
    if err != nil {
        panic(err)
    }

    // Get build information
    build, err := jobClient.GetBuild("deploy-app", -1) // -1 for last build
    if err != nil {
        panic(err)
    }

    fmt.Printf("Build #%d - Result: %s\n", build.Number, build.Result)
}
```

--------------------------------

### Configure Jenkins CLI Client

Source: https://github.com/jenkins-zh/jenkins-cli/blob/master/client/doc/README.md

Demonstrates how to configure the Jenkins CLI client by reading a YAML configuration file. It defines the structure for connection details like URL, username, and token, and then loads these into a Go struct for use by the client. It also includes logic to retrieve a crumb issuer for authenticated requests.

```Go
type Config struct {
	URL      string `yaml:"url"`
	UserName string `yaml:"username"`
	Token    string `yaml:"token"`
}

func GetJenkinsCore() (core client.JenkinsCore, e error) {
	// read configuration files
	jenkinsConfigPath := "./jenkins.yml"
	yamlFile, e := ioutil.ReadFile(jenkinsConfigPath)
	if e != nil {
		return
	}
	// yaml parse
	var config Config
	e = yaml.Unmarshal(yamlFile, &config)
	if e != nil {
		return
	}
	// capsulate JenkinsCore
	core = client.JenkinsCore{
		URL:      config.URL,
		UserName: config.UserName,
		Token:    config.Token,
	}
	crumbIssuer, e := core.GetCrumb()
	if e != nil {
		return
	} else if crumbIssuer != nil {
		core.JenkinsCrumb = *crumbIssuer
	}
	return
}
```

--------------------------------

### Manage Jenkins Servers with jcli

Source: https://context7.com/jenkins-zh/jenkins-cli/llms.txt

Provides commands for managing multiple Jenkins server configurations. Users can list, add, select, and remove servers. It also shows how to override the default server for a single command execution.

```bash
# List all configured Jenkins servers
jcli config list

# Select a different Jenkins server
jcli config select staging-jenkins

# Add a new Jenkins server
jcli config add --name production \
  --url https://jenkins.prod.example.com \
  --username admin \
  --token abc123def456

# Remove a Jenkins server
jcli config remove production

# Override server for single command
jcli job list --jenkins production
jcli job build deploy-prod --url https://jenkins.example.com \
  --username admin --token xyz789
```

--------------------------------

### Utilize Advanced jcli Options

Source: https://context7.com/jenkins-zh/jenkins-cli/llms.txt

Demonstrates advanced command-line options for jcli, including specifying a custom configuration file, skipping configuration loading, setting logger levels, running diagnostics, setting timeouts, and bypassing TLS verification.

```bash
# Use custom config file
jcli job list --configFile ~/custom-jenkins.yaml

# Skip config loading
jcli job list --config-load=false

# Set logger level
jcli job build my-job --logger-level debug

# Run diagnostics
jcli job list --doctor

# Set connection timeout
jcli job list --timeout 60

# Skip TLS verification
jcli job list --insecureSkipVerify true

# Direct URL connection (no config)
jcli job list \
  --url https://jenkins.example.com \
  --username admin \
  --token mytoken123
```

--------------------------------

### Configure Jenkins Proxy Connections

Source: https://context7.com/jenkins-zh/jenkins-cli/llms.txt

Shows how to configure proxy settings for Jenkins connections, both for single commands and within a configuration file. Supports authentication via username and password.

```bash
# Use proxy for single command
jcli plugin list --proxy http://proxy.corp.com:8080 \
  --proxy-auth username:password

# Disable proxy for single command
jcli job list --proxy-disable
```

```yaml
# Proxy in configuration file
jenkins_servers:
  - name: corporate
    url: https://jenkins.corp.example.com
    username: admin
    token: token-here
    proxy: http://proxy.corp.com:8080
    proxyAuth: proxyuser:proxypass
```

--------------------------------

### Operate Jenkins Jobs with jcli

Source: https://context7.com/jenkins-zh/jenkins-cli/llms.txt

This section outlines various Jenkins job operations using the Jenkins CLI (jcli). Commands include listing, searching, building, monitoring, and deleting jobs. Supports building with parameters via JSON or entry format, and building from files.

```bash
# List all jobs
jcli job list

# Search for specific jobs
jcli job search deploy

# Build a job
jcli job build my-pipeline

# Build with parameters (JSON format)
jcli job build my-job --param '{"version":"1.2.3","env":"staging"}'

# Build with parameters (entry format)
jcli job build my-job --param-entry version=1.2.3 --param-entry env=staging

# Build with file parameter
jcli job build upload-job --param-file artifact=./build/app.jar

# Build and wait for completion
jcli job build my-job --wait --wait-timeout 300

# Build and stream console log
jcli job build my-job --log

# Get build information
jcli job get my-pipeline

# View job console log
jcli job log my-job

# View specific build log
jcli job log my-job --build 42

# Stop a running build
jcli job stop my-job

# Delete a job
jcli job delete old-pipeline --batch

# Create a new job from XML
jcli job create new-job < job-config.xml

# Edit job configuration
jcli job edit my-pipeline
```

--------------------------------

### Generate Jenkins CLI Configuration

Source: https://context7.com/jenkins-zh/jenkins-cli/llms.txt

Generates configuration files for managing Jenkins connections. Supports interactive generation, copying to clipboard, and programmatic generation using Go. The configuration includes server details, mirrors, and the current server profile.

```bash
# Generate interactive config file
jcli config generate --interactive

# Generate and copy to clipboard
jcli config generate --copy

# Example YAML config structure
current: yourServer
jenkins_servers:
  - name: yourServer
    url: http://localhost:8080/jenkins
    username: admin
    token: 111e3a2f0231198855dceaff96f20540a9
    insecureSkipVerify: true
mirrors:
  - name: default
    url: http://mirrors.jenkins.io/
  - name: tsinghua
    url: https://mirrors.tuna.tsinghua.edu.cn/jenkins/
```

--------------------------------

### Define Command Hooks for jcli Operations

Source: https://context7.com/jenkins-zh/jenkins-cli/llms.txt

Illustrates how to define pre- and post-command hooks in a YAML configuration file to execute custom scripts or commands before or after specific jcli operations.

```yaml
# Configuration with hooks
preHooks:
  - path: job.build
    cmd: echo "Starting build..."
  - path: plugin.install
    cmd: ./scripts/notify-team.sh

postHooks:
  - path: job.build
    cmd: ./scripts/build-notification.sh
  - path: config.select
    cmd: echo "Switched Jenkins context"
```

--------------------------------

### Manage Jenkins Agents (Computers) with jcli

Source: https://context7.com/jenkins-zh/jenkins-cli/llms.txt

This section provides jcli commands for managing Jenkins agents (computers/nodes). It includes operations for listing, creating, launching, deleting, and viewing logs of Jenkins agents.

```bash
# List all Jenkins agents
jcli computer list

# Create a new agent
jcli computer create agent-01

# Launch an agent
jcli computer launch agent-01

# Delete an agent
jcli computer delete agent-01

# View agent logs
jcli computer log agent-01
```

--------------------------------

### Generate Shell Completion Scripts for jcli

Source: https://context7.com/jenkins-zh/jenkins-cli/llms.txt

Provides commands to generate shell completion scripts for bash, zsh, fish, and PowerShell, enabling auto-completion for jcli commands in the terminal.

```bash
# Generate bash completion
jcli completion bash > /etc/bash_completion.d/jcli

# Generate zsh completion
jcli completion zsh > "${fpath[1]}/_jcli"

# Generate fish completion
jcli completion fish > ~/.config/fish/completions/jcli.fish

# Generate PowerShell completion
jcli completion powershell > jcli.ps1
```

--------------------------------

### Jenkins User API Operations

Source: https://github.com/jenkins-zh/jenkins-cli/blob/master/client/doc/README.md

Defines the API for managing users within Jenkins. It includes functions for creating a new user with specified username and password, and for deleting an existing user by their username. These operations are handled by the `UserClient`.

```Go
// Create will create a user in Jenkins
func (q *UserClient) Create(username, password string) (user *UserForCreate, err error) {...}

// Delete will remove a user from Jenkins
func (q *UserClient) Delete(username string) (err error) {...}
```

--------------------------------

### Configure External Data URLs for jcli

Source: https://context7.com/jenkins-zh/jenkins-cli/llms.txt

This YAML configuration snippet shows how to define external data URLs for Jenkins instances within the jcli configuration. This allows 'jcli open' to access custom URLs like Grafana or SonarQube associated with a Jenkins server.

```yaml
# Config with external data URLs
jenkins_servers:
  - name: production
    url: https://jenkins.prod.example.com
    username: admin
    token: token-here
    data:
      grafana: https://grafana.prod.example.com
      sonar: https://sonarqube.prod.example.com
```

--------------------------------

### Configure jcli Proxy Settings

Source: https://github.com/jenkins-zh/jenkins-cli/blob/master/docs/book/en/proxy.md

This snippet demonstrates how to add proxy configuration to the jcli configuration file. Users can edit the configuration using `jcli config edit` and add 'proxy' and 'proxyAuth' fields to their jenkins_servers entries. This is essential for connecting to Jenkins instances located behind a firewall.

```yaml
jenkins_servers:
- name: dev
  url: http://192.168.1.10
  username: admin
  token: 11132c9ae4b20edbe56ac3e09cb5a3c8c2
  proxy: http://192.168.10.10:47586
  proxyAuth: username:password
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.