systemlink-cli 1.4.1__tar.gz → 1.4.2__tar.gz

{systemlink_cli-1.4.1 → systemlink_cli-1.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: systemlink-cli
-Version: 1.4.1
+Version: 1.4.2
 Summary: SystemLink Integrator CLI - cross-platform CLI for SystemLink workflows and templates.
 License-File: LICENSE
 Author: Fred Visser

{systemlink_cli-1.4.1 → systemlink_cli-1.4.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "systemlink-cli"
-version = "1.4.1"
+version = "1.4.2"
 description = "SystemLink Integrator CLI - cross-platform CLI for SystemLink workflows and templates."
 authors = ["Fred Visser <fred.visser@emerson.com>"]
 packages = [{ include = "slcli" }]

{systemlink_cli-1.4.1 → systemlink_cli-1.4.2}/slcli/_version.py

@@ -1,4 +1,4 @@
 """Version information for slcli."""
 
 # This file is auto-generated. Do not edit manually.
-__version__ = "1.4.1"
+__version__ = "1.4.2"

{systemlink_cli-1.4.1 → systemlink_cli-1.4.2}/slcli/config_click.py

@@ -8,7 +8,11 @@ from typing import Any, Optional
 import click
 import questionary
 
-from .platform import PLATFORM_SLE, PLATFORM_SLS, detect_platform
+from .platform import (
+    PLATFORM_SLE,
+    PLATFORM_SLS,
+    check_service_status,
+)
 from .profiles import ProfileConfig, Profile, check_config_file_permissions
 from .table_utils import output_formatted_list
 from .utils import ExitCodes
@@ -83,16 +87,41 @@ def _add_profile_impl(
         click.echo("⚠️  Warning: Adding HTTPS protocol to web URL.")
         web_url = f"https://{web_url}"
 
-    # Detect platform type
-    click.echo("Detecting platform type...")
-    platform = detect_platform(url, api_key.strip())
-
-    if platform == PLATFORM_SLE:
-        click.echo("  Platform: SystemLink Enterprise (Cloud)")
-    elif platform == PLATFORM_SLS:
-        click.echo("  Platform: SystemLink Server (On-Premises)")
+    # Detect platform type and check service status
+    click.echo("Checking server connectivity and services...")
+    status = check_service_status(url, api_key.strip())
+    platform = status["platform"]
+
+    if not status["server_reachable"]:
+        click.echo("  ⚠️  Could not connect to server", err=True)
+        click.echo("      Verify the URL is correct and the server is reachable.", err=True)
+        click.echo(
+            "      Profile will be saved — run login again when the server is available.",
+            err=True,
+        )
     else:
-        click.echo("  Platform: Unknown (will attempt all features)")
+        if platform == PLATFORM_SLE:
+            click.echo("  Platform: SystemLink Enterprise (Cloud)")
+        elif platform == PLATFORM_SLS:
+            click.echo("  Platform: SystemLink Server (On-Premises)")
+        else:
+            click.echo("  Platform: Unknown (will attempt all features)")
+
+        # Report authorization status
+        if status["auth_valid"] is False:
+            click.echo("  ⚠️  API key: Unauthorized — check that the key is valid", err=True)
+        elif status["auth_valid"] is True:
+            click.echo("  API key:  ✓ Authorized")
+
+        # Report individual service status
+        services = status.get("services", {})
+        problem_services = [
+            name for name, svc_status in services.items() if svc_status == "unauthorized"
+        ]
+        if problem_services and status["auth_valid"] is not False:
+            # Only show per-service issues if overall auth isn't completely invalid
+            for svc_name in problem_services:
+                click.echo(f"  ⚠️  {svc_name}: unauthorized", err=True)
 
     # Get default workspace (optional)
     if workspace is None:

{systemlink_cli-1.4.1 → systemlink_cli-1.4.2}/slcli/main.py

@@ -21,7 +21,6 @@ from .function_click import register_function_commands
 from .mcp_click import register_mcp_commands
 from .notebook_click import register_notebook_commands
 from .platform import (
-    PLATFORM_UNKNOWN,
     get_platform_info,
 )
 from .policy_click import register_policy_commands
@@ -295,11 +294,12 @@ def logout(profile: Optional[str], remove_all: bool, force: bool) -> None:
 
 @cli.command()
 @click.option("--format", "-f", type=click.Choice(["table", "json"]), default="table")
-def info(format: str) -> None:
+@click.option("--skip-health", is_flag=True, default=False, help="Skip live service health checks.")
+def info(format: str, skip_health: bool) -> None:
     """Show current configuration and detected platform."""
     from .profiles import ProfileConfig, get_active_profile
 
-    platform_info = get_platform_info()
+    platform_info = get_platform_info(skip_health=skip_health)
 
     # Add profile information
     cfg = ProfileConfig.load()
@@ -333,7 +333,14 @@ def info(format: str) -> None:
     click.echo("├" + "─" * content_width + "┤")
 
     # Connection status
-    status = "✓ Connected" if platform_info["logged_in"] else "✗ Not logged in"
+    if not platform_info["logged_in"]:
+        status = "✗ Not logged in"
+    elif platform_info.get("server_reachable") is False:
+        status = "✗ Server unreachable"
+    elif platform_info.get("auth_valid") is False:
+        status = "✗ API key unauthorized"
+    else:
+        status = "✓ Connected"
     click.echo(f"│  Status:    {status:<48}│")
 
     # Profile information
@@ -361,23 +368,24 @@ def info(format: str) -> None:
         workspace_display = truncate(workspace)
         click.echo(f"│  Workspace: {workspace_display:<48}│")
 
-    click.echo("├" + "─" * content_width + "┤")
-    click.echo("│" + "Feature Availability".center(content_width) + "│")
-    click.echo("├" + "─" * content_width + "┤")
-
-    features = platform_info.get("features", {})
-    if features:
-        for feature_name, available in features.items():
-            status_icon = "✓" if available else "✗"
-            status_text = "Available" if available else "Not available"
-            # Truncate feature name if needed
-            display_name = truncate(feature_name, 29)
-            click.echo(f"│  {status_icon} {display_name:<30} {status_text:<26}│")
-    else:
-        if platform_info["platform"] == PLATFORM_UNKNOWN:
-            click.echo("│  Run 'slcli login' to detect platform features.            │")
-        else:
-            click.echo("│  No feature information available.                          │")
+    # Service Health section (only when services were checked)
+    services = platform_info.get("services")
+    if services:
+        click.echo("├" + "─" * content_width + "┤")
+        click.echo("│" + "Service Health".center(content_width) + "│")
+        click.echo("├" + "─" * content_width + "┤")
+
+        status_display = {
+            "ok": ("✓", "OK"),
+            "unauthorized": ("✗", "Unauthorized"),
+            "not_found": ("—", "Not available"),
+            "error": ("✗", "Error"),
+            "unreachable": ("✗", "Unreachable"),
+        }
+        for svc_name, svc_status in services.items():
+            icon, text = status_display.get(svc_status, ("?", svc_status))
+            display_name = truncate(svc_name, 29)
+            click.echo(f"│  {icon} {display_name:<30} {text:<26}│")
 
     click.echo("└" + "─" * content_width + "┘\n")
 

{systemlink_cli-1.4.1 → systemlink_cli-1.4.2}/slcli/platform.py

@@ -8,7 +8,7 @@ import json
 import os
 import sys
 from functools import lru_cache
-from typing import Any, Dict
+from typing import Any, Dict, List, Optional
 
 import click
 import keyring
@@ -21,6 +21,7 @@ from .utils import ExitCodes, get_ssl_verify
 PLATFORM_SLE = "SLE"  # SystemLink Enterprise (cloud)
 PLATFORM_SLS = "SLS"  # SystemLink Server (on-premises)
 PLATFORM_UNKNOWN = "unknown"
+PLATFORM_UNREACHABLE = "unreachable"  # Server could not be contacted
 
 # Feature matrix: maps features to platform availability
 PLATFORM_FEATURES: Dict[str, Dict[str, bool]] = {
@@ -80,64 +81,21 @@ def _get_keyring_config() -> Dict[str, Any]:
 def detect_platform(api_url: str, api_key: str) -> str:
     """Detect the SystemLink platform type by probing endpoints.
 
-    Detection strategy:
-    1. Try SLE-only endpoint (/niworkorder/v1/query-testplan-templates)
-       - If accessible -> SLE
-    2. Check URL pattern (*.systemlink.io, *.lifecyclesolutions.ni.com)
-       - If matches -> SLE
-    3. Default to SLS for on-premises/custom URLs
+    Uses check_service_status to probe services and determine:
+    - Platform type (SLE vs SLS)
+    - Server reachability
+    Falls back to URL pattern matching when probe is inconclusive.
 
     Args:
         api_url: The SystemLink API base URL
         api_key: The API key for authentication
 
     Returns:
-        Platform identifier (PLATFORM_SLE, PLATFORM_SLS, or PLATFORM_UNKNOWN)
+        Platform identifier (PLATFORM_SLE, PLATFORM_SLS, PLATFORM_UNREACHABLE,
+        or PLATFORM_UNKNOWN)
     """
-    headers = {
-        "x-ni-api-key": api_key,
-        "Content-Type": "application/json",
-        "User-Agent": "SystemLink-CLI/1.0 (cross-platform)",
-    }
-    ssl_verify = get_ssl_verify()
-
-    # Strategy 1: Probe SLE-only endpoint (Work Order service)
-    try:
-        # This endpoint only exists on SLE
-        workorder_url = f"{api_url}/niworkorder/v1/query-testplan-templates"
-        resp = requests.post(
-            workorder_url,
-            headers=headers,
-            json={"take": 1},
-            verify=ssl_verify,
-            timeout=10,
-        )
-        # If we get a 200 or 400 (bad request but endpoint exists), it's SLE
-        if resp.status_code in (200, 400):
-            return PLATFORM_SLE
-        # 404 means endpoint doesn't exist -> likely SLS
-        if resp.status_code == 404:
-            return PLATFORM_SLS
-    except requests.RequestException:
-        # Connection error - continue with other detection methods
-        pass
-
-    # Strategy 2: URL pattern matching
-    # SLE (cloud and hosted) service has specific URL patterns
-    api_url_lower = api_url.lower()
-    sle_patterns = [
-        "api.systemlink.io",  # SLE production
-        "-api.lifecyclesolutions.ni.com",  # SLE dev/demo with -api suffix
-        "dev-api.lifecyclesolutions",
-        "demo-api.lifecyclesolutions",
-    ]
-    for pattern in sle_patterns:
-        if pattern in api_url_lower:
-            return PLATFORM_SLE
-
-    # Strategy 3: Default to SLS for on-premises deployments
-    # This includes on-prem servers that may use *.systemlink.io subdomains
-    return PLATFORM_SLS
+    status = check_service_status(api_url, api_key)
+    return status["platform"]
 
 
 def _detect_platform_from_url(api_url: str) -> str:
@@ -274,11 +232,130 @@ def require_feature(feature_name: str) -> None:
     sys.exit(ExitCodes.INVALID_INPUT)
 
 
-def get_platform_info() -> Dict[str, Any]:
+# Services to probe during health checks.
+# Each entry: (display_name, method, url_path)
+SERVICE_CHECKS: List[List[str]] = [
+    ["Auth", "GET", "/niauth/v1/policies"],
+    ["Test Monitor", "GET", "/nitestmonitor/v2/results?take=0"],
+    ["Asset Management", "POST", "/niapm/v1/query-assets"],
+    ["Systems", "POST", "/nisysmgmt/v1/query-systems"],
+    ["Tag", "GET", "/nitag/v2/tags?take=0"],
+    ["File", "POST", "/nifile/v1/service-groups/Default/search-files"],
+    ["Notebook", "POST", "/ninotebook/v1/notebook/query"],
+    ["Web Application", "POST", "/niapp/v1/webapps/query"],
+    ["Dynamic Form Fields", "GET", "/nidynamicformfields/v1/groups"],
+    ["Work Order", "POST", "/niworkorder/v1/query-testplan-templates"],
+]
+
+
+def check_service_status(api_url: str, api_key: str) -> Dict[str, Any]:
+    """Probe key SystemLink services and report their status.
+
+    Checks reachability, authorization, and availability of core services.
+
+    Args:
+        api_url: The SystemLink API base URL.
+        api_key: The API key for authentication.
+
+    Returns:
+        Dictionary with:
+        - server_reachable: bool - whether any service responded
+        - auth_valid: bool | None - whether the API key is authorized (None if unreachable)
+        - services: dict mapping service name to status string
+          ("ok", "unauthorized", "not_found", "error", "unreachable")
+        - platform: detected platform string (PLATFORM_SLE, PLATFORM_SLS,
+          PLATFORM_UNREACHABLE)
+    """
+    headers = {
+        "x-ni-api-key": api_key,
+        "Content-Type": "application/json",
+        "User-Agent": "SystemLink-CLI/1.0 (cross-platform)",
+    }
+    ssl_verify = get_ssl_verify()
+
+    services: Dict[str, str] = {}
+    any_responded = False
+    any_authorized = False
+    all_unauthorized = True
+
+    for display_name, method, url_path in SERVICE_CHECKS:
+        try:
+            full_url = f"{api_url}{url_path}"
+            if method == "POST":
+                resp = requests.post(
+                    full_url,
+                    headers=headers,
+                    json={"take": 1},
+                    verify=ssl_verify,
+                    timeout=10,
+                )
+            else:
+                resp = requests.get(
+                    full_url,
+                    headers=headers,
+                    verify=ssl_verify,
+                    timeout=10,
+                )
+            any_responded = True
+
+            if resp.status_code in (200, 400):
+                services[display_name] = "ok"
+                any_authorized = True
+                all_unauthorized = False
+            elif resp.status_code == 401:
+                services[display_name] = "unauthorized"
+            elif resp.status_code == 403:
+                services[display_name] = "unauthorized"
+            elif resp.status_code == 404:
+                services[display_name] = "not_found"
+                all_unauthorized = False
+            else:
+                services[display_name] = "error"
+                all_unauthorized = False
+        except requests.RequestException:
+            services[display_name] = "unreachable"
+
+    # Determine overall status
+    if not any_responded:
+        return {
+            "server_reachable": False,
+            "auth_valid": None,
+            "services": services,
+            "platform": PLATFORM_UNREACHABLE,
+        }
+
+    # Determine auth status: valid if any service accepted the key
+    # If all responding services returned 401/403, the key is invalid
+    auth_valid = any_authorized if any_responded else None
+    if all_unauthorized and any_responded:
+        auth_valid = False
+
+    # Determine platform from service responses
+    workorder_status = services.get("Work Order")
+    if workorder_status in ("ok",):
+        platform = PLATFORM_SLE
+    elif workorder_status == "not_found":
+        platform = PLATFORM_SLS
+    else:
+        # Fall back to URL pattern matching
+        platform = _detect_platform_from_url(api_url)
+
+    return {
+        "server_reachable": True,
+        "auth_valid": auth_valid,
+        "services": services,
+        "platform": platform,
+    }
+
+
+def get_platform_info(skip_health: bool = False) -> Dict[str, Any]:
     """Get detailed information about the current platform configuration.
 
+    Args:
+        skip_health: If True, skip live service health checks.
+
     Returns:
-        Dictionary with platform info including URL, platform type, and features.
+        Dictionary with platform info including URL, platform type, and services.
     """
     from .utils import get_api_key, get_base_url, get_web_url
 
@@ -304,11 +381,24 @@ def get_platform_info() -> Dict[str, Any]:
 
     active_profile = get_active_profile()
     if active_profile and active_profile.platform:
-        platform = active_profile.platform
+        stored_platform = active_profile.platform
     else:
         # Fall back to keyring config
         cfg = _get_keyring_config()
-        platform = cfg.get("platform", PLATFORM_UNKNOWN)
+        stored_platform = cfg.get("platform", PLATFORM_UNKNOWN)
+
+    # Live service health check when logged in
+    server_reachable: Optional[bool] = None
+    auth_valid: Optional[bool] = None
+    services: Optional[Dict[str, str]] = None
+    platform = stored_platform
+
+    if not skip_health and logged_in and isinstance(api_url, str) and api_url != "Not configured":
+        status = check_service_status(api_url, api_key)
+        server_reachable = status["server_reachable"]
+        auth_valid = status["auth_valid"]
+        services = status["services"]
+        platform = status["platform"]
 
     info: Dict[str, Any] = {
         "api_url": api_url,
@@ -316,14 +406,12 @@ def get_platform_info() -> Dict[str, Any]:
         "platform": platform,
         "platform_display": _get_platform_display_name(platform),
         "logged_in": logged_in,
+        "server_reachable": server_reachable,
+        "auth_valid": auth_valid,
     }
 
-    # Add feature availability if platform is known
-    if platform in PLATFORM_FEATURES:
-        info["features"] = {}
-        for feature, available in PLATFORM_FEATURES[platform].items():
-            display_name = FEATURE_DISPLAY_NAMES.get(feature, feature)
-            info["features"][display_name] = available
+    if services is not None:
+        info["services"] = services
 
     return info
 
@@ -341,5 +429,6 @@ def _get_platform_display_name(platform: str) -> str:
         PLATFORM_SLE: "SystemLink Enterprise",
         PLATFORM_SLS: "SystemLink Server",
         PLATFORM_UNKNOWN: "Unknown",
+        PLATFORM_UNREACHABLE: "Unreachable (could not connect to server)",
     }
     return names.get(platform, platform)

{systemlink_cli-1.4.1 → systemlink_cli-1.4.2}/slcli/skills/slcli/SKILL.md

@@ -468,7 +468,7 @@ Manage named connection profiles (dev, test, prod). Credentials are stored in
 ```bash
 slcli login [--profile NAME] [--url URL] [--api-key KEY] [--web-url URL] [--workspace NAME]
 slcli logout [--profile NAME] [--all] [--force]
-slcli info [-f json]                            # Show active profile and feature availability
+slcli info [-f json] [--skip-health]            # Show active profile and service health
 slcli completion [--shell SHELL] [--install]    # Generate or install shell tab completion
 
 slcli config list [-f json]                     # List all profiles

{systemlink_cli-1.4.1 → systemlink_cli-1.4.2}/slcli/system_click.py

@@ -1715,14 +1715,17 @@ def register_system_commands(cli: Any) -> None:
                 }
                 click.echo(json.dumps(result, indent=2))
             else:
-                click.echo("\nSystem Fleet Summary")
-                click.echo("──────────────────────────────────────")
-                click.echo(f"  Connected:      {connected}")
-                click.echo(f"  Disconnected:   {disconnected}")
-                click.echo(f"  Virtual:        {virtual}")
-                click.echo(f"  Pending:        {pending}")
-                click.echo("  ─────────────────")
-                click.echo(f"  Total:          {total}")
+                click.echo()
+                click.echo("┌────────────────────────┐")
+                click.echo("│ System Fleet Summary   │")
+                click.echo("├────────────────┬───────┤")
+                click.echo(f"│ Connected      │ {connected:>5} │")
+                click.echo(f"│ Disconnected   │ {disconnected:>5} │")
+                click.echo(f"│ Virtual        │ {virtual:>5} │")
+                click.echo(f"│ Pending        │ {pending:>5} │")
+                click.echo("├────────────────┼───────┤")
+                click.echo(f"│ Total          │ {total:>5} │")
+                click.echo("└────────────────┴───────┘")
                 click.echo()
 
         except Exception as exc:  # noqa: BLE001