python-jcli 0.1.0__py3-none-any.whl

jcli/plugins/node.py

@@ -0,0 +1,134 @@
+"""Jenkins Node management commands."""
+
+from __future__ import annotations
+
+import click
+
+from jcli.cli_helpers import get_client, get_formatter
+from jcli.sdk.node import create_node, delete_node, get_node, list_nodes, toggle_offline
+
+
+@click.group("node", help="Manage Jenkins nodes (agents).")
+def node_group():
+    """Node management commands."""
+
+
+@node_group.command("list")
+@click.pass_context
+def list_nodes_cmd(ctx: click.Context):
+    """List all Jenkins nodes."""
+    fmt = get_formatter(ctx)
+    client = get_client(ctx)
+
+    try:
+        nodes = list_nodes(client)
+        if nodes:
+            headers = ["Name", "Online", "Temporarily Offline", "Architecture"]
+            rows = [
+                [
+                    n.get("displayName", "?"),
+                    "Yes" if not n.get("offline", True) else "No",
+                    "Yes" if n.get("temporarilyOffline", False) else "No",
+                    n.get("monitorData", {}).get("hudson.node_monitors.ArchitectureMonitor", "?"),
+                ]
+                for n in nodes
+            ]
+            fmt.print_table(headers, rows, title="Jenkins Nodes")
+        else:
+            fmt.print_info("No nodes found.")
+    except Exception as exc:
+        fmt.print_error(str(exc))
+
+
+@node_group.command("get")
+@click.argument("name")
+@click.pass_context
+def get_node_cmd(ctx: click.Context, name: str):
+    """Get details of a specific node."""
+    fmt = get_formatter(ctx)
+    client = get_client(ctx)
+
+    try:
+        node = get_node(client, name)
+        if fmt.format_type == "json":
+            fmt.print_json(node)
+        else:
+            headers = ["Property", "Value"]
+            rows = [
+                ["Display Name", node.get("displayName", "?")],
+                ["Description", node.get("description", "") or "-"],
+                ["Offline", "Yes" if node.get("offline", True) else "No"],
+                ["Temporarily Offline", "Yes" if node.get("temporarilyOffline", False) else "No"],
+                ["Num Executors", str(node.get("numExecutors", "?"))],
+                ["Idle", "Yes" if node.get("idle", False) else "No"],
+                ["JNLP Agent", "Yes" if node.get("jnlpAgent", False) else "No"],
+            ]
+            # Add monitor data if available
+            monitor = node.get("monitorData", {})
+            if monitor:
+                for key, val in monitor.items():
+                    if key.startswith("hudson.node_monitors."):
+                        label = key.replace("hudson.node_monitors.", "")
+                        rows.append([f"Monitor: {label}", str(val)])
+            fmt.print_table(headers, rows, title=f"Node: {name}")
+    except Exception as exc:
+        fmt.print_error(str(exc))
+
+
+@node_group.command("delete")
+@click.argument("name")
+@click.option("--force", "-f", is_flag=True, help="Skip confirmation prompt.")
+@click.pass_context
+def delete_node_cmd(ctx: click.Context, name: str, force: bool):
+    """Delete a Jenkins node (agent)."""
+    fmt = get_formatter(ctx)
+    client = get_client(ctx)
+
+    if not force:
+        if not click.confirm(f"Are you sure you want to delete node '{name}'?"):
+            fmt.print_info("Delete cancelled.")
+            return
+
+    try:
+        delete_node(client, name)
+        fmt.print_success(f"Node '{name}' deleted successfully.")
+    except Exception as exc:
+        fmt.print_error(str(exc))
+
+
+@node_group.command("toggle")
+@click.argument("name")
+@click.option("--message", "-m", default="", help="Reason for toggling offline/online.")
+@click.pass_context
+def toggle_node_cmd(ctx: click.Context, name: str, message: str):
+    """Toggle a node offline or online."""
+    fmt = get_formatter(ctx)
+    client = get_client(ctx)
+
+    try:
+        toggle_offline(client, name, msg=message)
+        fmt.print_success(f"Node '{name}' toggled successfully.")
+    except Exception as exc:
+        fmt.print_error(str(exc))
+
+
+@node_group.command("create")
+@click.argument("name")
+@click.option("--executors", type=int, default=1, help="Number of executors (default: 1).")
+@click.option("--remote-fs", default="/tmp", help="Remote filesystem root (default: /tmp).")
+@click.option("--labels", default="", help="Node labels.")
+@click.pass_context
+def create_node_cmd(ctx: click.Context, name: str, executors: int, remote_fs: str, labels: str):
+    """Create a new Jenkins agent node."""
+    client = get_client(ctx)
+    fmt = get_formatter(ctx)
+    try:
+        create_node(client, name, num_executors=executors, remote_fs=remote_fs, labels=labels)
+        fmt.print_success(f"Node '{name}' created.")
+    except Exception as exc:
+        fmt.print_error(str(exc))
+
+
+def register(parent_group):
+    """Register the node subgroup under the parent Click group."""
+    parent_group.add_command(node_group)

jcli/plugins/pipeline.py

@@ -0,0 +1,108 @@
+"""Jenkins Pipeline management commands."""
+
+import click
+
+from jcli.cli_helpers import get_client, get_formatter
+from jcli.sdk.exceptions import (
+    JenkinsAPIError,
+    JenkinsAuthError,
+    JenkinsConnectionError,
+    JenkinsNotFoundError,
+)
+from jcli.sdk.pipeline import (
+    get_pending_input,
+    get_pipeline_log,
+    get_pipeline_stages,
+    validate_jenkinsfile,
+)
+
+
+@click.group("pipeline", help="Manage Jenkins pipelines.")
+def pipeline_group():
+    """Pipeline management commands."""
+
+
+@pipeline_group.command("stages")
+@click.argument("job_name")
+@click.argument("build_number")
+@click.pass_context
+def stages(ctx, job_name, build_number):
+    """List stages for a Pipeline build.
+
+    JOB_NAME is the Pipeline job name.
+    BUILD_NUMBER is the build number to query.
+    """
+    client = get_client(ctx)
+    fmt = get_formatter(ctx)
+
+    try:
+        result = get_pipeline_stages(client, job_name, build_number)
+        fmt.print_json(result)
+    except (JenkinsNotFoundError, JenkinsAuthError, JenkinsConnectionError, JenkinsAPIError) as exc:
+        fmt.print_error(str(exc))
+
+
+@pipeline_group.command("log")
+@click.argument("job_name")
+@click.argument("build_number")
+@click.argument("node_id")
+@click.pass_context
+def log(ctx, job_name, build_number, node_id):
+    """Get log output for a Pipeline step.
+
+    JOB_NAME is the Pipeline job name.
+    BUILD_NUMBER is the build number to query.
+    NODE_ID is the flow node ID from stage/step info.
+    """
+    client = get_client(ctx)
+    fmt = get_formatter(ctx)
+
+    try:
+        result = get_pipeline_log(client, job_name, build_number, node_id)
+        fmt.print_json(result)
+    except (JenkinsNotFoundError, JenkinsAuthError, JenkinsConnectionError, JenkinsAPIError) as exc:
+        fmt.print_error(str(exc))
+
+
+@pipeline_group.command("validate")
+@click.argument("file_path", type=click.Path(exists=True, dir_okay=False))
+@click.pass_context
+def validate(ctx, file_path):
+    """Validate a Jenkinsfile against the Jenkins server.
+
+    FILE_PATH is the path to the Jenkinsfile to validate.
+    """
+    with open(file_path, "r", encoding="utf-8") as f:
+        content = f.read()
+
+    client = get_client(ctx)
+    fmt = get_formatter(ctx)
+
+    result = validate_jenkinsfile(client, content)
+
+    fmt.print_json(result)
+
+
+@pipeline_group.command("pending")
+@click.argument("job_name")
+@click.argument("build_number")
+@click.pass_context
+def pending(ctx, job_name, build_number):
+    """Show pending input actions for a Pipeline build.
+
+    JOB_NAME is the Pipeline job name.
+    BUILD_NUMBER is the build number to query.
+    """
+    client = get_client(ctx)
+    fmt = get_formatter(ctx)
+
+    try:
+        result = get_pending_input(client, job_name, build_number)
+        fmt.print_json(result)
+    except (JenkinsNotFoundError, JenkinsAuthError, JenkinsConnectionError, JenkinsAPIError) as exc:
+        fmt.print_error(str(exc))
+
+
+def register(parent_group):
+    """Register the pipeline subgroup under the parent Click group."""
+    parent_group.add_command(pipeline_group)

jcli/plugins/plugin.py

@@ -0,0 +1,173 @@
+"""Jenkins Plugin management commands."""
+
+from __future__ import annotations
+
+import click
+
+from jcli.cli_helpers import get_client, get_formatter
+from jcli.sdk.plugin import (
+    check_plugin_updates,
+    get_plugin,
+    install_plugins,
+    list_plugins,
+    uninstall_plugin,
+)
+
+
+def _parse_plugin_spec(spec: str) -> tuple[str, str | None]:
+    """Parse a plugin spec like 'git' or 'git@5.0.0'.
+
+    Returns:
+        (short_name, version_or_None)
+    """
+    if "@" in spec:
+        name, _, version = spec.partition("@")
+        return name, version
+    return spec, None
+
+
+# ------------------------------------------------------------------
+# Plugin command group
+# ------------------------------------------------------------------
+
+
+@click.group("plugin", help="Manage Jenkins plugins.")
+@click.pass_context
+def plugin_group(ctx):
+    """Plugin management commands."""
+
+
+@plugin_group.command("list")
+@click.pass_context
+def list_cmd(ctx):
+    """List installed Jenkins plugins."""
+    client = get_client(ctx)
+    fmt = get_formatter(ctx)
+
+    try:
+        plugins = list_plugins(client)
+    except Exception as exc:
+        fmt.print_error(str(exc))
+        raise SystemExit(1)
+
+    if not plugins:
+        fmt.print_info("No plugins found.")
+        return
+
+    headers = ["Name", "Version", "Active", "Update"]
+    rows = [
+        [p.get("shortName", "?"), p.get("version", "?"),
+         "Yes" if p.get("active") else "No",
+         "Yes" if p.get("hasUpdate") else "No"]
+        for p in plugins
+    ]
+    fmt.print_table(headers, rows, title="Installed Plugins")
+
+
+@plugin_group.command("get")
+@click.argument("name")
+@click.pass_context
+def get_cmd(ctx, name):
+    """Show details for a single plugin."""
+    client = get_client(ctx)
+    fmt = get_formatter(ctx)
+
+    try:
+        plugin = get_plugin(client, name)
+    except Exception as exc:
+        fmt.print_error(str(exc))
+        raise SystemExit(1)
+
+    # Display all fields in a vertical key-value table
+    headers = ["Field", "Value"]
+    rows = [[str(k), str(v)] for k, v in plugin.items()] if plugin else []
+    fmt.print_table(
+        headers,
+        rows,
+        title=f"Plugin: {plugin.get('shortName', name)}" if plugin else f"Plugin {name}",
+    )
+
+
+@plugin_group.command("install")
+@click.argument("plugin_spec")
+@click.pass_context
+def install_cmd(ctx, plugin_spec):
+    """Install a Jenkins plugin.
+
+    PLUGIN_SPEC can be just a plugin name (e.g. 'git') or
+    name@version (e.g. 'git@5.0.0') to install a specific version.
+    """
+    client = get_client(ctx)
+    fmt = get_formatter(ctx)
+
+    name, version = _parse_plugin_spec(plugin_spec)
+    plugins_dict: dict[str, str | None] = {name: version}
+
+    try:
+        install_plugins(client, plugins_dict)
+    except Exception as exc:
+        fmt.print_error(str(exc))
+        raise SystemExit(1)
+
+    msg = f"Plugin '{name}' installed successfully"
+    if version:
+        msg += f" (version {version})"
+    fmt.print_success(msg)
+
+
+@plugin_group.command("uninstall")
+@click.argument("name")
+@click.pass_context
+def uninstall_cmd(ctx, name):
+    """Uninstall a Jenkins plugin.
+
+    The plugin is scheduled for removal; a server restart is typically
+    required to complete the uninstall.
+    """
+    client = get_client(ctx)
+    fmt = get_formatter(ctx)
+
+    try:
+        uninstall_plugin(client, name)
+    except Exception as exc:
+        fmt.print_error(str(exc))
+        raise SystemExit(1)
+
+    fmt.print_success(f"Plugin '{name}' scheduled for uninstall (restart may be required)")
+
+
+@plugin_group.command("check-updates")
+@click.pass_context
+def check_updates_cmd(ctx):
+    """Check for available plugin updates."""
+    client = get_client(ctx)
+    fmt = get_formatter(ctx)
+    try:
+        result = check_plugin_updates(client)
+        fmt.print_info("Plugin update check triggered. Run 'jcli plugin list' to see results.")
+        if isinstance(result, dict) and result:
+            fmt.print_json(result)
+    except Exception as exc:
+        fmt.print_error(str(exc))
+
+
+@plugin_group.command("restart")
+@click.option("--yes", "-y", is_flag=True, help="Skip confirmation prompt.")
+@click.pass_context
+def restart_cmd(ctx, yes):
+    """Restart Jenkins after plugin changes."""
+    if not yes:
+        click.confirm("Restart Jenkins server?", abort=True)
+    client = get_client(ctx)
+    fmt = get_formatter(ctx)
+    try:
+        from jcli.sdk.system import safe_restart
+        safe_restart(client)
+        fmt.print_success("Jenkins restart initiated.")
+    except Exception as exc:
+        fmt.print_error(str(exc))
+
+
+def register(parent_group):
+    """Register the plugin subgroup under the parent Click group."""
+    parent_group.add_command(plugin_group)