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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: systemlink-cli
-Version: 1.4.1
+Version: 1.4.3
 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.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "systemlink-cli"
-version = "1.4.1"
+version = "1.4.3"
 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.3}/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.3"

{systemlink_cli-1.4.1 → systemlink_cli-1.4.3}/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
@@ -60,6 +64,7 @@ def _add_profile_impl(
     elif not url.startswith("https://"):
         click.echo("⚠️  Warning: Adding HTTPS protocol to URL.")
         url = f"https://{url}"
+    url = url.rstrip("/")
 
     # Get API key - either from flag or prompt
     if not api_key:
@@ -82,17 +87,49 @@ def _add_profile_impl(
     elif not web_url.startswith("https://"):
         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)")
+    web_url = web_url.rstrip("/")
+
+    # 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")
+
+        if status.get("elasticsearch_available") is False:
+            click.echo("  File query: query-files-linq (Elasticsearch unavailable)")
+            click.echo(
+                "      'slcli file list' will fall back automatically; 'slcli file query' requires search-files."
+            )
+
+        # 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.3}/slcli/file_click.py

@@ -10,9 +10,10 @@ from typing import Any, Dict, List, Optional
 
 import click
 import questionary
+import requests as requests_lib
 
 from .cli_utils import validate_output_format
-from .universal_handlers import UniversalResponseHandler
+from .universal_handlers import FilteredResponse, UniversalResponseHandler
 from .utils import (
     ExitCodes,
     format_success,
@@ -29,6 +30,120 @@ def _get_file_service_url() -> str:
     return f"{get_base_url()}/nifile/v1/service-groups/Default"
 
 
+def _get_search_files_url() -> str:
+    """Get the search-files endpoint URL."""
+    return f"{_get_file_service_url()}/search-files"
+
+
+def _is_search_files_unavailable(exc: requests_lib.HTTPError) -> bool:
+    """Return whether the search-files endpoint is unavailable."""
+    return exc.response is not None and exc.response.status_code in (404, 501)
+
+
+def _exit_search_files_required() -> None:
+    """Exit with a user-facing message when search-files is unavailable."""
+    click.echo(
+        "✗ File query requires the search-files endpoint, but Elasticsearch is not available.",
+        err=True,
+    )
+    click.echo(
+        "  Use 'slcli file list' for automatic fallback to query-files-linq.",
+        err=True,
+    )
+    sys.exit(ExitCodes.INVALID_INPUT)
+
+
+def _search_files_with_fallback(
+    payload: Dict[str, Any],
+    workspace_id: Optional[str],
+    name_filter: Optional[str],
+    id_filter: Optional[str],
+) -> Any:
+    """Try search-files endpoint, fall back to query-files-linq if unavailable.
+
+    The search-files endpoint requires additional software (DataFinder) to be
+    installed. If it is not available (HTTP 404), we fall back to query-files-linq.
+
+    Args:
+        payload: The search-files request payload
+        workspace_id: Optional workspace ID filter
+        name_filter: Optional name filter string
+        id_filter: Optional comma-separated file IDs
+
+    Returns:
+        Response object (real or FilteredResponse)
+    """
+    try:
+        return make_api_request(
+            "POST", _get_search_files_url(), payload=payload, handle_errors=False
+        )
+    except requests_lib.HTTPError as exc:
+        if _is_search_files_unavailable(exc):
+            return _query_files_linq_fallback(
+                take=payload.get("take", 25),
+                workspace_id=workspace_id,
+                name_filter=name_filter,
+                id_filter=id_filter,
+            )
+        raise
+
+
+def _query_files_linq_fallback(
+    take: int,
+    workspace_id: Optional[str],
+    name_filter: Optional[str],
+    id_filter: Optional[str],
+) -> Any:
+    """List files using query-files-linq as a fallback when search-files is unavailable.
+
+    Args:
+        take: Maximum number of files to return
+        workspace_id: Optional workspace ID filter
+        name_filter: Optional name filter string (applied client-side)
+        id_filter: Optional comma-separated file IDs
+
+    Returns:
+        Response or FilteredResponse with availableFiles data
+    """
+    base_url = _get_file_service_url()
+    url = f"{base_url}/query-files-linq"
+
+    # Build LINQ-style filter
+    filter_parts: List[str] = []
+
+    if id_filter:
+        ids = [fid.strip() for fid in id_filter.split(",")]
+        id_conditions = [f'id = "{fid}"' for fid in ids]
+        filter_parts.append("(" + " or ".join(id_conditions) + ")")
+
+    linq_payload: Dict[str, Any] = {}
+
+    # Request more if we need to filter client-side by name
+    if name_filter:
+        linq_payload["take"] = max(take * 4, 1000)
+    else:
+        linq_payload["take"] = take
+
+    if filter_parts:
+        linq_payload["filter"] = " and ".join(filter_parts)
+
+    # Workspace filtering via query parameter
+    if workspace_id:
+        url += f"?workspace={workspace_id}"
+
+    resp = make_api_request("POST", url, payload=linq_payload)
+
+    # Client-side name filtering (query-files-linq doesn't support name wildcards)
+    if name_filter:
+        data = resp.json()
+        files = data.get("availableFiles", [])
+        needle = name_filter.lower()
+        filtered = [f for f in files if needle in _get_file_name(f).lower()][:take]
+        return FilteredResponse({"availableFiles": filtered})
+
+    return resp
+
+
 def _format_file_size(size_bytes: Optional[int]) -> str:
     """Format file size in human-readable format.
 
@@ -178,9 +293,6 @@ def register_file_commands(cli: Any) -> None:
         """
         format_output = validate_output_format(format)
 
-        # Use search-files endpoint for better performance
-        url = f"{_get_file_service_url()}/search-files"
-
         try:
             # Resolve workspace name to ID if needed
             workspace_id = None
@@ -189,7 +301,7 @@ def register_file_commands(cli: Any) -> None:
                 workspace_map = get_workspace_map()
                 workspace_id = resolve_workspace_filter(workspace, workspace_map)
 
-            # Build search filter
+            # Build search filter for search-files endpoint
             filter_parts = []
 
             if workspace_id:
@@ -221,7 +333,13 @@ def register_file_commands(cli: Any) -> None:
             if filter_parts:
                 payload["filter"] = " AND ".join(filter_parts)
 
-            resp = make_api_request("POST", url, payload=payload)
+            # Try search-files, fall back to query-files-linq if unavailable
+            resp = _search_files_with_fallback(
+                payload=payload,
+                workspace_id=workspace_id,
+                name_filter=name_filter,
+                id_filter=id_filter,
+            )
 
             def file_formatter(file_item: dict) -> list:
                 name = _get_file_name(file_item)
@@ -567,11 +685,8 @@ def register_file_commands(cli: Any) -> None:
         """
         format_output = validate_output_format(format)
 
-        # Use search-files endpoint for better performance
-        url = f"{_get_file_service_url()}/search-files"
-
         try:
-            # Build request body
+            # Build request body for search-files
             query_body: Dict[str, Any] = {
                 "take": take if format_output.lower() == "json" else (take if take != 25 else 1000),
                 "orderByDescending": descending,
@@ -584,6 +699,7 @@ def register_file_commands(cli: Any) -> None:
                 filter_parts.append(filter_query)
 
             # Resolve workspace name to ID if needed
+            workspace_id = None
             workspace = get_effective_workspace(workspace)
             if workspace:
                 workspace_map = get_workspace_map()
@@ -598,7 +714,12 @@ def register_file_commands(cli: Any) -> None:
             else:
                 query_body["orderBy"] = "updated"
 
-            resp = make_api_request("POST", url, payload=query_body)
+            resp = make_api_request(
+                "POST",
+                _get_search_files_url(),
+                payload=query_body,
+                handle_errors=False,
+            )
 
             def file_formatter(file_item: dict) -> list:
                 name = _get_file_name(file_item)
@@ -620,6 +741,10 @@ def register_file_commands(cli: Any) -> None:
                 page_size=take,
             )
 
+        except requests_lib.HTTPError as exc:
+            if _is_search_files_unavailable(exc):
+                _exit_search_files_required()
+            handle_api_error(exc)
         except Exception as exc:
             handle_api_error(exc)
 

{systemlink_cli-1.4.1 → systemlink_cli-1.4.3}/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,34 @@ 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.            │")
+    file_query_endpoint = platform_info.get("file_query_endpoint")
+    if file_query_endpoint:
+        if platform_info.get("elasticsearch_available") is False:
+            file_query_display = f"{file_query_endpoint} (Elasticsearch unavailable)"
         else:
-            click.echo("│  No feature information available.                          │")
+            file_query_display = str(file_query_endpoint)
+        file_query_display = truncate(file_query_display)
+        click.echo(f"│  File Query:{file_query_display:<48}│")
+
+    # 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"),
+            "fallback": ("!", "Fallback (no Elasticsearch)"),
+            "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.3}/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]] = {
@@ -55,6 +56,9 @@ FEATURE_DISPLAY_NAMES: Dict[str, str] = {
     "webapp": "Web Applications",
 }
 
+FILE_SEARCH_PATH = "/nifile/v1/service-groups/Default/search-files"
+FILE_QUERY_LINQ_PATH = "/nifile/v1/service-groups/Default/query-files-linq"
+
 
 def _get_keyring_config() -> Dict[str, Any]:
     """Attempt to read a single JSON config entry from keyring.
@@ -80,64 +84,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 +235,220 @@ 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", FILE_SEARCH_PATH],
+    ["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 get_file_query_capability(api_url: str, api_key: str) -> Dict[str, Any]:
+    """Determine which file query endpoint is available for this server."""
+    headers = {
+        "x-ni-api-key": api_key,
+        "Content-Type": "application/json",
+        "User-Agent": "SystemLink-CLI/1.0 (cross-platform)",
+    }
+    ssl_verify = get_ssl_verify()
+
+    try:
+        search_resp = requests.post(
+            f"{api_url}{FILE_SEARCH_PATH}",
+            headers=headers,
+            json={"take": 1},
+            verify=ssl_verify,
+            timeout=10,
+        )
+        if search_resp.status_code in (200, 400):
+            return {
+                "status": "ok",
+                "file_query_endpoint": "search-files",
+                "elasticsearch_available": True,
+            }
+        if search_resp.status_code in (401, 403):
+            return {
+                "status": "unauthorized",
+                "file_query_endpoint": "search-files",
+                "elasticsearch_available": True,
+            }
+        if search_resp.status_code not in (404, 501):
+            return {
+                "status": "error" if search_resp.status_code >= 500 else "not_found",
+                "file_query_endpoint": None,
+                "elasticsearch_available": True,
+            }
+    except requests.RequestException:
+        return {
+            "status": "unreachable",
+            "file_query_endpoint": None,
+            "elasticsearch_available": None,
+        }
+
+    try:
+        fallback_resp = requests.post(
+            f"{api_url}{FILE_QUERY_LINQ_PATH}",
+            headers=headers,
+            json={"take": 1},
+            verify=ssl_verify,
+            timeout=10,
+        )
+        if fallback_resp.status_code in (200, 400):
+            return {
+                "status": "fallback",
+                "file_query_endpoint": "query-files-linq",
+                "elasticsearch_available": False,
+            }
+        if fallback_resp.status_code in (401, 403):
+            return {
+                "status": "unauthorized",
+                "file_query_endpoint": "query-files-linq",
+                "elasticsearch_available": False,
+            }
+        if fallback_resp.status_code in (404, 501):
+            return {
+                "status": "not_found",
+                "file_query_endpoint": None,
+                "elasticsearch_available": False,
+            }
+        return {
+            "status": "error",
+            "file_query_endpoint": None,
+            "elasticsearch_available": False,
+        }
+    except requests.RequestException:
+        return {
+            "status": "unreachable",
+            "file_query_endpoint": None,
+            "elasticsearch_available": False,
+        }
+
+
+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")
+                - file_query_endpoint: selected file query endpoint, if available
+                - elasticsearch_available: bool | None - whether search-files is available
+        - 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,
+            "file_query_endpoint": None,
+            "elasticsearch_available": None,
+            "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)
+
+    file_capability = get_file_query_capability(api_url, api_key)
+    services["File"] = file_capability["status"]
+
+    return {
+        "server_reachable": True,
+        "auth_valid": auth_valid,
+        "services": services,
+        "file_query_endpoint": file_capability["file_query_endpoint"],
+        "elasticsearch_available": file_capability["elasticsearch_available"],
+        "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 +474,28 @@ 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
+    file_query_endpoint: Optional[str] = None
+    elasticsearch_available: Optional[bool] = None
+
+    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"]
+        file_query_endpoint = status.get("file_query_endpoint")
+        elasticsearch_available = status.get("elasticsearch_available")
 
     info: Dict[str, Any] = {
         "api_url": api_url,
@@ -316,14 +503,17 @@ 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 file_query_endpoint is not None:
+        info["file_query_endpoint"] = file_query_endpoint
+    if elasticsearch_available is not None:
+        info["elasticsearch_available"] = elasticsearch_available
+
+    if services is not None:
+        info["services"] = services
 
     return info
 
@@ -341,5 +531,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.3}/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.3}/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