systemlink-cli 1.27.2__tar.gz → 1.27.3__tar.gz

{systemlink_cli-1.27.2 → systemlink_cli-1.27.3}/PKG-INFO

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

{systemlink_cli-1.27.2 → systemlink_cli-1.27.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "systemlink-cli"
-version = "1.27.2"
+version = "1.27.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.27.2 → systemlink_cli-1.27.3}/slcli/_version.py

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

{systemlink_cli-1.27.2 → systemlink_cli-1.27.3}/slcli/main.py

@@ -43,6 +43,7 @@ from .templates_click import register_templates_commands
 from .testmonitor_click import register_testmonitor_commands
 from .user_click import register_user_commands
 from .utils import describe_config_source
+from .version_click import register_version_commands
 from .webapp_click import register_webapp_commands
 from .workitem_click import register_workitem_commands
 from .workspace_click import register_workspace_commands
@@ -71,7 +72,15 @@ def _configure_rich_click_command_groups() -> None:
         "slcli": [
             {
                 "name": "Configure",
-                "commands": ["config", "login", "logout", "info", "completion", "example"],
+                "commands": [
+                    "config",
+                    "login",
+                    "logout",
+                    "info",
+                    "version",
+                    "completion",
+                    "example",
+                ],
             },
             {
                 "name": "Administer",
@@ -363,7 +372,7 @@ def cli(ctx: base_click.Context, version: bool, profile: Optional[str]) -> None:
 
     # Check for mandatory migration BEFORE any command runs
     # Skip migration check only for version flag and config migrate command
-    if ctx.invoked_subcommand not in (None, "config"):
+    if ctx.invoked_subcommand not in (None, "config", "version"):
         from .profiles import ProfileConfig, has_keyring_credentials, migrate_from_keyring
 
         config_path = ProfileConfig.get_config_path()
@@ -769,5 +778,6 @@ register_testmonitor_commands(cli)
 register_webapp_commands(cli)
 register_skill_commands(cli)
 register_user_commands(cli)
+register_version_commands(cli)
 register_workitem_commands(cli)
 register_workspace_commands(cli)

{systemlink_cli-1.27.2 → systemlink_cli-1.27.3}/slcli/platform.py

@@ -168,8 +168,9 @@ def get_platform() -> str:
 
     Detection priority:
     1. SYSTEMLINK_PLATFORM environment variable (explicit, most reliable)
-    2. Stored platform from keyring config (set during login via endpoint probing)
-    3. Return PLATFORM_UNKNOWN if no explicit or stored platform is available
+    2. Platform stored on the active profile (set during login via endpoint probing)
+    3. Stored platform from keyring config (legacy fallback)
+    4. Return PLATFORM_UNKNOWN if no explicit or stored platform is available
 
     Note: Results are cached for performance. Use clear_platform_cache() to reset.
 
@@ -182,11 +183,26 @@ def get_platform() -> str:
     if env_platform in (PLATFORM_SLE, PLATFORM_SLS):
         return env_platform
 
-    # Priority 2: Stored platform from keyring config (set during login)
-    # This was detected via endpoint probing, which is reliable
+    if not any(os.environ.get(name) for name in ("SLCLI_API_URL", "SYSTEMLINK_API_URL")):
+        try:
+            from .profiles import get_active_profile
+
+            profile = get_active_profile()
+            profile_platform = str(profile.platform or "").upper() if profile else ""
+            if profile_platform in (PLATFORM_SLE, PLATFORM_SLS):
+                return profile_platform
+        except (
+            FileNotFoundError,
+            json.JSONDecodeError,
+            KeyError,
+            AttributeError,
+            click.ClickException,
+        ):
+            pass
+
     cfg = _get_keyring_config()
     if cfg:
-        platform = cfg.get("platform", "")
+        platform = str(cfg.get("platform", "")).upper()
         if platform in (PLATFORM_SLE, PLATFORM_SLS):
             return platform
 

{systemlink_cli-1.27.2 → systemlink_cli-1.27.3}/slcli/skill_click.py

@@ -6,11 +6,14 @@ from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple
 
 import click
+from packaging.version import InvalidVersion, Version
 
+from ._version import __version__
 from .utils import ExitCodes, format_success
 
 SKILL_NAME = "slcli"
 _FALLBACK_SKILL_CHOICES = [SKILL_NAME]
+_VERSION_FILENAME = ".slcli-version"
 
 # Mapping of client name -> (personal skills dir, project subdir relative to repo root)
 # personal dir uses Path.home() so it's always resolved at call time via _personal_dir().
@@ -119,6 +122,23 @@ def _expand_skill_selection(skill_names: Optional[List[str]] = None) -> List[str
     return requested
 
 
+def _skill_installation_status(destination_root: Path, skill_name: str) -> str:
+    """Return the version status of an installed skill."""
+    destination_dir = destination_root / skill_name
+    if not destination_dir.exists():
+        return "missing"
+
+    version_file = destination_dir / _VERSION_FILENAME
+    if not version_file.exists():
+        return "unversioned"
+
+    try:
+        installed_version = version_file.read_text(encoding="utf-8").strip()
+        return "current" if Version(installed_version) >= Version(__version__) else "outdated"
+    except (InvalidVersion, OSError):
+        return "unversioned"
+
+
 def install_skills_to_directory(
     directory: Path,
     skill_names: Optional[List[str]] = None,
@@ -150,6 +170,7 @@ def install_skills_to_directory(
                 destination_dir.unlink()
 
         shutil.copytree(source_dir, destination_dir)
+        (destination_dir / _VERSION_FILENAME).write_text(f"{__version__}\n", encoding="utf-8")
 
     return len(selected_skills)
 
@@ -184,6 +205,19 @@ def _resolve_destinations(clients: List[str], scope: str) -> List[Path]:
     return seen
 
 
+def _requested_destinations(
+    directory: Optional[Path], client: Optional[str], scope: Optional[str]
+) -> List[Path]:
+    """Resolve either a custom skills directory or client-specific destinations."""
+    if directory is not None:
+        if client is not None or scope is not None:
+            raise ValueError("--directory cannot be combined with --client or --scope")
+        return [directory.expanduser()]
+
+    selected_clients = CLIENT_CHOICES if client == "all" else [client or "agents"]
+    return _resolve_destinations(selected_clients, scope or "project")
+
+
 def register_skill_commands(cli: Any) -> None:
     """Register the skill command group with the CLI.
 
@@ -217,6 +251,13 @@ def register_skill_commands(cli: Any) -> None:
         default=None,
         help="personal (~/ home dirs), project (current repo), or both.",
     )
+    @click.option(
+        "--directory",
+        "-d",
+        type=click.Path(file_okay=False, path_type=Path),
+        default=None,
+        help="Install directly into this skills directory.",
+    )
     @click.option(
         "--force",
         "-F",
@@ -225,7 +266,11 @@ def register_skill_commands(cli: Any) -> None:
         help="Overwrite existing skill installation without prompting.",
     )
     def install_skill(
-        skill: Optional[str], client: Optional[str], scope: Optional[str], force: bool
+        skill: Optional[str],
+        client: Optional[str],
+        scope: Optional[str],
+        directory: Optional[Path],
+        force: bool,
     ) -> None:
         """Install bundled skills for supported AI clients."""
         requested_skills: Optional[List[str]]
@@ -235,11 +280,9 @@ def register_skill_commands(cli: Any) -> None:
             assert skill is not None
             requested_skills = [skill.lower()]
         selected_skill_names = _expand_skill_selection(requested_skills)
-        selected_clients = CLIENT_CHOICES if client == "all" else [client or "agents"]
-        selected_scope = scope or "project"
-        destinations = _resolve_destinations(selected_clients, selected_scope)
 
         try:
+            destinations = _requested_destinations(directory, client, scope)
             installed_count = 0
             for destination in destinations:
                 installed_count += install_skills_to_directory(
@@ -257,6 +300,9 @@ def register_skill_commands(cli: Any) -> None:
         except FileNotFoundError as exc:
             click.echo(f"✗ {exc}", err=True)
             sys.exit(ExitCodes.GENERAL_ERROR)
+        except OSError as exc:
+            click.echo(f"✗ Unable to install skills: {exc}", err=True)
+            sys.exit(ExitCodes.GENERAL_ERROR)
 
         format_success(
             "Installed bundled AI skills",
@@ -266,3 +312,60 @@ def register_skill_commands(cli: Any) -> None:
                 "Installed": str(installed_count),
             },
         )
+
+    @skill.command(name="check")
+    @click.option(
+        "--skill",
+        "-k",
+        type=click.Choice(SKILL_CHOICES + ["all"], case_sensitive=False),
+        default=None,
+        help=f"Skill to check ({', '.join(SKILL_CHOICES)}, or all).",
+    )
+    @click.option(
+        "--client",
+        "-c",
+        type=click.Choice(CLIENT_CHOICES + ["all"], case_sensitive=False),
+        default=None,
+        help="AI client installation to check (agents, claude, or all).",
+    )
+    @click.option(
+        "--scope",
+        "-s",
+        type=click.Choice(["personal", "project", "both"], case_sensitive=False),
+        default=None,
+        help="personal (~/ home dirs), project (current repo), or both.",
+    )
+    @click.option(
+        "--directory",
+        "-d",
+        type=click.Path(file_okay=False, path_type=Path),
+        default=None,
+        help="Check skills directly in this directory.",
+    )
+    def check_skills(
+        skill: Optional[str],
+        client: Optional[str],
+        scope: Optional[str],
+        directory: Optional[Path],
+    ) -> None:
+        """Check whether installed skills match the bundled version."""
+        requested_skills = None if skill in (None, "all") else [skill.lower()]
+
+        try:
+            selected_skill_names = _expand_skill_selection(requested_skills)
+            destinations = _requested_destinations(directory, client, scope)
+        except ValueError as exc:
+            click.echo(f"✗ {exc}", err=True)
+            sys.exit(ExitCodes.INVALID_INPUT)
+
+        needs_update = False
+        click.echo(f"Bundled skill version: {__version__}")
+        for destination in destinations:
+            for skill_name in selected_skill_names:
+                status = _skill_installation_status(destination, skill_name)
+                indicator = "✓" if status == "current" else "✗"
+                click.echo(f"{indicator} {destination / skill_name}: {status}")
+                needs_update = needs_update or status != "current"
+
+        if needs_update:
+            sys.exit(ExitCodes.GENERAL_ERROR)

{systemlink_cli-1.27.2 → systemlink_cli-1.27.3}/slcli/skills/slcli/SKILL.md

@@ -47,17 +47,33 @@ Load only what the current task needs.
 
 ## Default approach
 
-1. Prefer long-form flags in generated commands.
-2. Use `--format json` when the result will be filtered, transformed, or piped
+1. At the start of troubleshooting or a substantial `slcli` workflow, run the
+  update preflight once per session:
+
+  ```bash
+  slcli version check
+  slcli skill check --client CLIENT --scope SCOPE
+  ```
+
+  Set `CLIENT` and `SCOPE` to the active skill installation, or use
+  `--directory PATH` for a custom skills directory. If the CLI is outdated,
+  recommend the update command printed by `version check`. If the skill is
+  missing, unversioned, or outdated, recommend `slcli skill install` with the
+  same target and `--force`. Ask before running either update because they
+  modify the user's environment. A failed or unavailable check is advisory:
+  report it briefly and continue the requested workflow unless version skew
+  is the likely cause.
+2. Prefer long-form flags in generated commands.
+3. Use `--format json` when the result will be filtered, transformed, or piped
    into other tools.
-3. Use `--summary --group-by` for aggregation before fetching large raw result sets.
-4. Use convenience filters first, then fall back to `--filter` with `--substitution` for complex queries.
-5. Stay scoped to the user’s requested resource or workflow.
-6. Load deeper references only when the command surface alone is not enough.
-7. For example authoring or review, load `example-authoring.md` before proposing YAML.
-8. Prefer workspace IDs over names in scripted workflows when an endpoint is strict about identity.
-9. Use `make_api_request` from `slcli.utils` for helper scripts so auth, SSL, and error handling stay consistent.
-10. For datasheet imports, default to autonomy when the product or workspace can be resolved unambiguously.
+4. Use `--summary --group-by` for aggregation before fetching large raw result sets.
+5. Use convenience filters first, then fall back to `--filter` with `--substitution` for complex queries.
+6. Stay scoped to the user’s requested resource or workflow.
+7. Load deeper references only when the command surface alone is not enough.
+8. For example authoring or review, load `example-authoring.md` before proposing YAML.
+9. Prefer workspace IDs over names in scripted workflows when an endpoint is strict about identity.
+10. Use `make_api_request` from `slcli.utils` for helper scripts so auth, SSL, and error handling stay consistent.
+11. For datasheet imports, default to autonomy when the product or workspace can be resolved unambiguously.
 
 ## Common command groups
 
@@ -82,7 +98,8 @@ Load only what the current task needs.
 | `user` | User management | `list`, `get`, `create`, `update` |
 | `auth` | Authorization policies | `policy list/create`, `template list` |
 | `workspace` | Workspaces | `list`, `get` |
-| `skill` | AI skill installation | `install` |
+| `version` | CLI update hygiene | `check` |
+| `skill` | AI skill installation | `install`, `check` |
 | `example` | Demo provisioning | `list`, `install`, `delete` |
 
 Example package fixtures are declared as `package` resources after a `feed`

{systemlink_cli-1.27.2 → systemlink_cli-1.27.3}/slcli/skills/slcli/references/commands.md

@@ -26,6 +26,7 @@ Complete option reference for all `slcli` command groups.
 - [workitem — Work item, template, and workflow management](#workitem--work-item-template-and-workflow-management)
 - [workflow — Workflow management](#workflow--workflow-management)
 - [webapp — Web application management](#webapp--web-application-management)
+- [version — CLI update check](#version--cli-update-check)
 - [skill — AI skill installation](#skill--ai-skill-installation)
 - [example — Built-in example resource provisioning](#example--built-in-example-resource-provisioning)
 - [Scope and capability discovery](#scope-and-capability-discovery)
@@ -946,12 +947,32 @@ metadata, carries the icon into the package, writes the matching control-file fi
 generated `.nipkg`, and emits a thin `manifest.json` with `schemaVersion`, `nipkgFile`,
 `sha256`, and any configured provenance fields.
 
+## version — CLI update check
+
+Compare the installed CLI with the latest PyPI release and identify the update command for
+its installation method.
+
+```bash
+slcli version                         # Show the installed version without a network request
+slcli version check                   # Check PyPI and show update guidance
+slcli version check --format json     # Structured output for automation
+slcli version check --fail-if-outdated
+```
+
+`version check` detects Homebrew, Scoop, pipx, uv, pip, standalone binaries, and development
+checkouts. By default, finding an update still exits successfully; use `--fail-if-outdated`
+when an outdated installation should fail automation. A lookup failure exits with the network
+error code and must not be interpreted as confirmation that the CLI is current.
+
 ## skill — AI skill installation
 
-Install bundled skills for supported AI clients.
+Install bundled skills for supported AI clients, or directly into a custom skills directory.
 
 ```bash
 slcli skill install --skill [slcli|all] --client [agents|claude|all] --scope [personal|project|both]
+slcli skill install --skill [slcli|all] --directory PATH
+slcli skill check --skill [slcli|all] --client [agents|claude|all] --scope [personal|project|both]
+slcli skill check --skill [slcli|all] --directory PATH
 ```
 
 Client paths:
@@ -963,6 +984,22 @@ Client paths:
 Notes:
 
 - `agents` is the default client in interactive mode.
+- `--directory` is the directory that directly contains skill folders and cannot be combined
+  with `--client` or `--scope`.
+- Installed skills carry the `slcli` release version. `skill check` exits nonzero if a skill is
+  missing, predates the bundled version, or was installed before version metadata was added.
+- Use `skill install --force` to update an existing installation.
+- For hygiene checks, specify the client and scope that contain the active skill, then use the
+  same target to update it:
+
+  ```bash
+  slcli skill check --client agents --scope project
+  slcli skill install --client agents --scope project --force
+  ```
+
+  Substitute `claude`, `personal`, or `--directory PATH` when that is where the active skill is
+  installed. Checking the wrong target can report a current skill as missing.
+
 - The bundled `slcli` skill now covers the previous standalone workflow skills.
 
 ## example — Built-in example resource provisioning

{systemlink_cli-1.27.2 → systemlink_cli-1.27.3}/slcli/skills/slcli/references/troubleshooting.md

@@ -2,6 +2,28 @@
 
 Common issues and workarounds when using `slcli` or scripting against SystemLink APIs.
 
+## Update preflight
+
+Before deeper troubleshooting, check the CLI and the active installed skill once per session:
+
+```bash
+slcli version check
+slcli skill check --client <CLIENT> --scope <SCOPE>
+```
+
+Use `--directory <PATH>` instead of `--client` and `--scope` for a custom skill location. If
+the CLI is outdated, recommend the manager-specific command printed by `version check`. If the
+skill check reports `missing`, `unversioned`, or `outdated`, recommend updating the same target:
+
+```bash
+slcli skill install --client <CLIENT> --scope <SCOPE> --force
+```
+
+Obtain the user's approval before running an update. If either check fails because the command
+is unavailable or the network cannot be reached, note that version status is unknown and
+continue troubleshooting. Give version skew more weight when the failure involves unknown
+commands, changed options, output shape, packaging, or skill instructions.
+
 ## Effective profile and workspace scope
 
 Resolve the workspace and profile independently before querying resources. A

systemlink_cli-1.27.3/slcli/version_click.py

@@ -0,0 +1,199 @@
+"""Version checking and update guidance for slcli."""
+
+from __future__ import annotations
+
+import sys
+from dataclasses import asdict, dataclass
+from enum import Enum
+from importlib.metadata import PackageNotFoundError, distribution
+from pathlib import Path
+from typing import Any, Optional
+
+import click
+import requests
+from packaging.version import InvalidVersion, Version
+
+from ._version import __version__
+from .rich_output import print_json
+from .utils import ExitCodes
+
+PYPI_URL = "https://pypi.org/pypi/systemlink-cli/json"
+RELEASES_URL = "https://github.com/ni-kismet/systemlink-cli/releases/latest"
+
+
+class InstallMethod(str, Enum):
+    """Supported slcli installation methods."""
+
+    HOMEBREW = "homebrew"
+    SCOOP = "scoop"
+    PIPX = "pipx"
+    UV = "uv"
+    PIP = "pip"
+    STANDALONE = "standalone"
+    DEVELOPMENT = "development"
+    UNKNOWN = "unknown"
+
+
+@dataclass(frozen=True)
+class VersionCheckResult:
+    """Result returned by a version check.
+
+    Attributes:
+        current_version: Installed slcli version.
+        latest_version: Latest version published to PyPI.
+        status: One of ``outdated``, ``current``, or ``ahead``.
+        install_method: Detected installation method.
+        update_command: Suggested update command, when available.
+    """
+
+    current_version: str
+    latest_version: str
+    status: str
+    install_method: str
+    update_command: Optional[str]
+
+
+def fetch_latest_version() -> str:
+    """Return the latest published systemlink-cli version from PyPI."""
+    response = requests.get(PYPI_URL, timeout=5)
+    response.raise_for_status()
+    payload: Any = response.json()
+    try:
+        version = payload["info"]["version"]
+    except (KeyError, TypeError) as exc:
+        raise ValueError("PyPI returned an unexpected response") from exc
+    if not isinstance(version, str) or not version:
+        raise ValueError("PyPI returned an invalid version")
+    try:
+        Version(version)
+    except InvalidVersion as exc:
+        raise ValueError(f"PyPI returned an invalid version: {version}") from exc
+    return version
+
+
+def _path_contains(path: Path, *parts: str) -> bool:
+    """Return whether a path contains the given consecutive components."""
+    lowered_parts = tuple(part.lower() for part in path.parts)
+    expected = tuple(part.lower() for part in parts)
+    width = len(expected)
+    return any(lowered_parts[index : index + width] == expected for index in range(len(path.parts)))
+
+
+def detect_install_method() -> InstallMethod:
+    """Detect how the running slcli installation is managed."""
+    executable = Path(sys.executable).resolve()
+
+    if getattr(sys, "frozen", False):
+        if _path_contains(executable, "cellar", "slcli"):
+            return InstallMethod.HOMEBREW
+        if _path_contains(executable, "scoop", "apps", "slcli"):
+            return InstallMethod.SCOOP
+        return InstallMethod.STANDALONE
+
+    if _path_contains(executable, "pipx", "venvs", "systemlink-cli"):
+        return InstallMethod.PIPX
+    if _path_contains(executable, "uv", "tools", "systemlink-cli"):
+        return InstallMethod.UV
+
+    project_root = Path(__file__).resolve().parent.parent
+    if (project_root / "pyproject.toml").is_file() and (project_root / ".git").exists():
+        return InstallMethod.DEVELOPMENT
+
+    try:
+        distribution("systemlink-cli")
+    except PackageNotFoundError:
+        return InstallMethod.UNKNOWN
+    return InstallMethod.PIP
+
+
+def get_update_command(install_method: InstallMethod) -> Optional[str]:
+    """Return the update command for an installation method, when available."""
+    commands = {
+        InstallMethod.HOMEBREW: "brew upgrade slcli",
+        InstallMethod.SCOOP: "scoop update slcli",
+        InstallMethod.PIPX: "pipx upgrade systemlink-cli",
+        InstallMethod.UV: "uv tool upgrade systemlink-cli",
+        InstallMethod.PIP: f'"{sys.executable}" -m pip install --upgrade systemlink-cli',
+        InstallMethod.DEVELOPMENT: "git pull && poetry install",
+    }
+    return commands.get(install_method)
+
+
+def check_version(current_version: str = __version__) -> VersionCheckResult:
+    """Compare the current slcli version with the latest published version."""
+    latest_version = fetch_latest_version()
+    current = Version(current_version)
+    latest = Version(latest_version)
+    status = "outdated" if current < latest else "current" if current == latest else "ahead"
+    install_method = detect_install_method()
+    return VersionCheckResult(
+        current_version=current_version,
+        latest_version=latest_version,
+        status=status,
+        install_method=install_method.value,
+        update_command=get_update_command(install_method),
+    )
+
+
+def _render_version_check(result: VersionCheckResult) -> None:
+    """Render a human-readable version check result."""
+    click.echo(f"Current version: {result.current_version}")
+    click.echo(f"Latest version:  {result.latest_version}")
+    click.echo(f"Installed with:  {result.install_method}")
+    click.echo()
+
+    if result.status == "current":
+        click.echo("✓ slcli is up to date")
+    elif result.status == "ahead":
+        click.echo("Current version is newer than the latest published version")
+    elif result.update_command:
+        click.echo("A newer version is available:")
+        click.echo(f"  {result.update_command}")
+    else:
+        click.echo("A newer version is available.")
+        click.echo(f"Download it from {RELEASES_URL}")
+
+
+def register_version_commands(cli: Any) -> None:
+    """Register version commands with the CLI."""
+
+    @cli.group(invoke_without_command=True)
+    @click.pass_context
+    def version(ctx: click.Context) -> None:
+        """Show the installed version and check for updates."""
+        if ctx.invoked_subcommand is None:
+            click.echo(f"slcli version {__version__}")
+
+    @version.command(name="check")
+    @click.option(
+        "--format",
+        "-f",
+        "format_output",
+        type=click.Choice(["text", "json"]),
+        default="text",
+        show_default=True,
+        help="Output format",
+    )
+    @click.option(
+        "--fail-if-outdated",
+        is_flag=True,
+        help="Exit with code 1 when a newer version is available",
+    )
+    def check(format_output: str, fail_if_outdated: bool) -> None:
+        """Check whether this is the latest slcli version."""
+        try:
+            result = check_version()
+        except InvalidVersion as exc:
+            click.echo(f"✗ Invalid version: {exc}", err=True)
+            sys.exit(ExitCodes.INVALID_INPUT)
+        except (requests.RequestException, ValueError) as exc:
+            click.echo(f"✗ Unable to retrieve the latest slcli version: {exc}", err=True)
+            sys.exit(ExitCodes.NETWORK_ERROR)
+
+        if format_output == "json":
+            print_json(asdict(result))
+        else:
+            _render_version_check(result)
+
+        if fail_if_outdated and result.status == "outdated":
+            sys.exit(ExitCodes.GENERAL_ERROR)

{systemlink_cli-1.27.2 → systemlink_cli-1.27.3}/slcli/webapp_click.py

@@ -20,6 +20,7 @@ import questionary
 import requests
 
 from .cli_utils import is_interactive_environment, validate_output_format
+from .platform import PLATFORM_SLS, get_platform
 from .skill_click import install_skills_to_directory
 from .universal_handlers import UniversalResponseHandler
 from .utils import (
@@ -96,8 +97,9 @@ def _build_published_webapp_url(
 ) -> str:
     """Return the best available published URL for a webapp.
 
-    Prefers the friendly SystemLink web UI URL and falls back to any explicit
-    URL-like property returned by the service, then the raw content endpoint.
+    Uses the WebVI host route for SystemLink Server and otherwise prefers the
+    friendly SystemLink web UI URL. Falls back to any explicit URL-like property
+    returned by the service, then the raw content endpoint.
     """
     from urllib.parse import quote
 
@@ -133,6 +135,10 @@ def _build_published_webapp_url(
         if mapped_workspace_name:
             workspace_name = mapped_workspace_name
 
+    if get_platform() == PLATFORM_SLS and webapp_id:
+        web_base = get_web_url().rstrip("/")
+        return f"{web_base}/#/webvihost/view/webvi/{quote(webapp_id, safe='')}"
+
     if resolved_name and workspace_name:
         web_base = get_web_url().rstrip("/")
         return f"{web_base}/webapps/app/{quote(workspace_name)}/{quote(resolved_name)}"