snowflake-cli 3.8.2__tar.gz → 3.9.0__tar.gz

{snowflake_cli-3.8.2 → snowflake_cli-3.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowflake-cli
-Version: 3.8.2
+Version: 3.9.0
 Summary: Snowflake CLI
 Project-URL: Source code, https://github.com/snowflakedb/snowflake-cli
 Project-URL: Bug Tracker, https://github.com/snowflakedb/snowflake-cli/issues
@@ -222,7 +222,7 @@ Requires-Dist: gitpython==3.1.44
 Requires-Dist: jinja2==3.1.6
 Requires-Dist: packaging
 Requires-Dist: pip
-Requires-Dist: pluggy==1.5.0
+Requires-Dist: pluggy==1.6.0
 Requires-Dist: prompt-toolkit==3.0.51
 Requires-Dist: pydantic==2.11.4
 Requires-Dist: pyyaml==6.0.2
@@ -239,7 +239,7 @@ Requires-Dist: urllib3<2.5,>=1.24.3
 Provides-Extra: development
 Requires-Dist: coverage==7.8.0; extra == 'development'
 Requires-Dist: factory-boy==3.3.3; extra == 'development'
-Requires-Dist: faker==37.1.0; extra == 'development'
+Requires-Dist: faker==37.3.0; extra == 'development'
 Requires-Dist: pre-commit>=3.5.0; extra == 'development'
 Requires-Dist: pytest-httpserver==1.1.3; extra == 'development'
 Requires-Dist: pytest-randomly==3.16.0; extra == 'development'

{snowflake_cli-3.8.2 → snowflake_cli-3.9.0}/RELEASE-NOTES.md

@@ -23,6 +23,27 @@
 ## Fixes and improvements
 
 
+# v3.9.0
+
+## Deprecations
+
+## New additions
+* Added `--encryption` flag to `snow stage create` command defining the type of encryption for all files on the stage.
+
+## Fixes and improvements
+* Fix `use` commands error if current database is not set.
+
+
+# v3.8.3
+
+## Deprecations
+
+## New additions
+* Added `--private-link` flag to `snow spcs image-registry url` command for retrieving private link URLs.
+
+## Fixes and improvements
+
+
 # v3.8.2
 
 ## Deprecations
@@ -43,6 +64,7 @@
 * Upgrade message is printed to stderr.
 * Fixed `snowflake.core` import issue on newer Python versions
 
+
 # v3.8.0
 
 ## Deprecations
@@ -62,6 +84,17 @@
 * Move `enable_release_channels` from global feature flag to project level.
 * Fixed `snow spcs service metrics` command to accept fully qualified service names.
 
+
+# v3.7.2
+
+## Deprecations
+
+## New additions
+
+## Fixes and improvements
+* Fix error appearing on help messages after click BCR update.
+
+
 # v3.7.1
 
 ## Deprecations

{snowflake_cli-3.8.2 → snowflake_cli-3.9.0}/pyproject.toml

@@ -31,7 +31,7 @@ dependencies = [
   "jinja2==3.1.6",
   "packaging",
   "pip",
-  "pluggy==1.5.0",
+  "pluggy==1.6.0",
   "prompt-toolkit==3.0.51",
   "pydantic==2.11.4",
   "requests==2.32.3",
@@ -59,7 +59,7 @@ classifiers = [
 
 [project.optional-dependencies]
 development = [
-  "Faker==37.1.0",
+  "Faker==37.3.0",
   "coverage==7.8.0",
   "factory-boy==3.3.3",
   "pre-commit>=3.5.0",

{snowflake_cli-3.8.2 → snowflake_cli-3.9.0}/scripts/cleanup.py

@@ -52,6 +52,18 @@ def remove_resources(single: str, plural: str, known_instances: t.List[str], rol
             remove_resource(resource_type=single, item=item, role=role)
 
 
+def _get_private_key_data() -> t.Dict[str, str | None]:
+    if private_key_raw := os.getenv(
+        "SNOWFLAKE_CONNECTIONS_INTEGRATION_PRIVATE_KEY_RAW"
+    ):
+        return {"private_key_raw": private_key_raw}
+    return {
+        "private_key_file": os.getenv(
+            "SNOWFLAKE_CONNECTIONS_INTEGRATION_PRIVATE_KEY_FILE"
+        )
+    }
+
+
 if __name__ == "__main__":
     role = os.getenv("SNOWFLAKE_CONNECTIONS_INTEGRATION_ROLE", "INTEGRATION_TESTS")
     config = {
@@ -59,12 +71,10 @@ if __name__ == "__main__":
         "host": os.getenv("SNOWFLAKE_CONNECTIONS_INTEGRATION_HOST"),
         "account": os.getenv("SNOWFLAKE_CONNECTIONS_INTEGRATION_ACCOUNT"),
         "user": os.getenv("SNOWFLAKE_CONNECTIONS_INTEGRATION_USER"),
-        "private_key_raw": os.getenv(
-            "SNOWFLAKE_CONNECTIONS_INTEGRATION_PRIVATE_KEY_RAW"
-        ),
         "database": "SNOWCLI_DB",
         "schema": "public",
         "role": role,
+        **_get_private_key_data(),
     }
     config = {k: v for k, v in config.items() if v is not None}
     update_connection_details_with_private_key(config)
@@ -92,6 +102,7 @@ if __name__ == "__main__":
             "USERADMIN",
             "INTEGRATION_TESTS",
             "APP_PUBLIC",
+            "TEST_ROLE",
         ],
     }
 

{snowflake_cli-3.8.2 → snowflake_cli-3.9.0}/scripts/packaging/Dockerfile

@@ -3,9 +3,9 @@ FROM ubuntu:18.04 AS base
 ENV HOME=/root
 
 RUN apt -y update
-RUN apt -y install -y software-properties-common binutils
+RUN apt -y install -y software-properties-common binutils --fix-missing
 RUN add-apt-repository ppa:deadsnakes/ppa
-RUN apt install -y ruby\
+RUN apt install -y --fix-missing ruby\
   squashfs-tools\
   rpm\
   vim \

{snowflake_cli-3.8.2 → snowflake_cli-3.9.0}/snyk/requirements.txt

@@ -4,7 +4,7 @@ PyYAML==6.0.2
 jinja2==3.1.6
 packaging
 pip
-pluggy==1.5.0
+pluggy==1.6.0
 prompt-toolkit==3.0.51
 pydantic==2.11.4
 requests==2.32.3
@@ -17,7 +17,7 @@ snowflake.core==1.4.0
 tomlkit==0.13.2
 typer==0.15.2
 urllib3>=1.24.3,<2.5
-Faker==37.1.0
+Faker==37.3.0
 coverage==7.8.0
 factory-boy==3.3.3
 pre-commit>=3.5.0

{snowflake_cli-3.8.2 → snowflake_cli-3.9.0}/src/snowflake/cli/__about__.py

@@ -16,7 +16,7 @@ from __future__ import annotations
 
 from enum import Enum, unique
 
-VERSION = "3.8.2"
+VERSION = "3.9.0"
 
 
 @unique

{snowflake_cli-3.8.2 → snowflake_cli-3.9.0}/src/snowflake/cli/_app/commands_registration/builtin_plugins.py

@@ -15,6 +15,7 @@
 from snowflake.cli._plugins.auth.keypair import plugin_spec as auth_plugin_spec
 from snowflake.cli._plugins.connection import plugin_spec as connection_plugin_spec
 from snowflake.cli._plugins.cortex import plugin_spec as cortex_plugin_spec
+from snowflake.cli._plugins.dbt import plugin_spec as dbt_plugin_spec
 from snowflake.cli._plugins.git import plugin_spec as git_plugin_spec
 from snowflake.cli._plugins.helpers import plugin_spec as migrate_plugin_spec
 from snowflake.cli._plugins.init import plugin_spec as init_plugin_spec
@@ -52,6 +53,7 @@ def get_builtin_plugin_name_to_plugin_spec():
         "init": init_plugin_spec,
         "workspace": workspace_plugin_spec,
         "plugin": plugin_plugin_spec,
+        "dbt": dbt_plugin_spec,
         "logs": logs_plugin_spec,
     }
 

{snowflake_cli-3.8.2 → snowflake_cli-3.9.0}/src/snowflake/cli/_app/version_check.py

@@ -9,7 +9,8 @@ from snowflake.cli.api.cli_global_context import get_cli_context
 from snowflake.cli.api.secure_path import SecurePath
 from snowflake.connector.config_manager import CONFIG_MANAGER
 
-REPOSITORY_URL = "https://pypi.org/pypi/snowflake-cli/json"
+REPOSITORY_URL_PIP = "https://pypi.org/pypi/snowflake-cli/json"
+REPOSITORY_URL_BREW = "https://formulae.brew.sh/api/formula/snowflake-cli.json"
 
 
 def get_new_version_msg() -> str | None:
@@ -48,12 +49,21 @@ class _VersionCache:
     @staticmethod
     def _get_version_from_pypi() -> str | None:
         headers = {"Content-Type": "application/vnd.pypi.simple.v1+json"}
-        response = requests.get(REPOSITORY_URL, headers=headers, timeout=3)
+        response = requests.get(REPOSITORY_URL_PIP, headers=headers, timeout=3)
         response.raise_for_status()
-        return response.json()["info"]["version"]
+        return response.json().get("info", {}).get("version", None)
+
+    @staticmethod
+    def _get_version_from_brew() -> str | None:
+        response = requests.get(REPOSITORY_URL_BREW, timeout=3)
+        response.raise_for_status()
+        return response.json().get("versions", {}).get("stable", None)
 
     def _update_latest_version(self) -> Version | None:
-        version = self._get_version_from_pypi()
+        # Use brew version, fallback to pypi if brew is not available.
+        # Brew repo takes longer to propagate the upgrade and is triggered later in our release process,
+        # we treat it as "slowest point" and determinant that the released version is available.
+        version = self._get_version_from_brew() or self._get_version_from_pypi()
         if version is None:
             return None
         self._save_latest_version(version)

{snowflake_cli-3.8.2 → snowflake_cli-3.9.0}/src/snowflake/cli/_plugins/cortex/commands.py

@@ -15,13 +15,17 @@
 from __future__ import annotations
 
 import sys
+from enum import Enum
 from pathlib import Path
 from typing import List, Optional
 
 import click
 import typer
 from click import UsageError
-from snowflake.cli._plugins.cortex.constants import DEFAULT_MODEL
+from snowflake.cli._plugins.cortex.constants import (
+    DEFAULT_BACKEND,
+    DEFAULT_MODEL,
+)
 from snowflake.cli._plugins.cortex.manager import CortexManager
 from snowflake.cli._plugins.cortex.types import (
     Language,
@@ -36,7 +40,7 @@ from snowflake.cli.api.commands.overrideable_parameter import (
     OverrideableOption,
 )
 from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
-from snowflake.cli.api.constants import PYTHON_3_12
+from snowflake.cli.api.constants import DEFAULT_SIZE_LIMIT_MB, PYTHON_3_12
 from snowflake.cli.api.output.types import (
     CollectionResult,
     CommandResult,
@@ -115,6 +119,11 @@ def search(
     return CollectionResult(response.results)
 
 
+class Backend(Enum):
+    SQL = "sql"
+    REST = "rest"
+
+
 @app.command(
     name="complete",
     requires_connection=True,
@@ -130,6 +139,11 @@ def complete(
         "--model",
         help="String specifying the model to be used.",
     ),
+    backend: Optional[Backend] = typer.Option(
+        DEFAULT_BACKEND,
+        "--backend",
+        help="String specifying whether to use sql or rest backend.",
+    ),
     file: Optional[Path] = ExclusiveReadableFileOption(
         help="JSON file containing conversation history to be used to generate a completion. Cannot be combined with TEXT argument.",
     ),
@@ -143,18 +157,30 @@ def complete(
 
     manager = CortexManager()
 
+    is_file_input: bool = False
     if text:
-        result_text = manager.complete_for_prompt(
-            text=Text(text),
+        prompt = text
+    elif file:
+        prompt = SecurePath(file).read_text(file_size_limit_mb=DEFAULT_SIZE_LIMIT_MB)
+        is_file_input = True
+    else:
+        raise UsageError("Either --file option or TEXT argument has to be provided.")
+
+    if backend == Backend.SQL:
+        result_text = manager.complete(
+            text=Text(prompt),
             model=Model(model),
+            is_file_input=is_file_input,
         )
-    elif file:
-        result_text = manager.complete_for_conversation(
-            conversation_json_file=SecurePath(file),
+    elif backend == Backend.REST:
+        root = get_cli_context().snow_api_root
+        result_text = manager.rest_complete(
+            text=Text(prompt),
             model=Model(model),
+            root=root,
         )
     else:
-        raise UsageError("Either --file option or TEXT argument has to be provided.")
+        raise UsageError("--backend option should be either rest or sql.")
 
     return MessageResult(result_text.strip())
 

{snowflake_cli-3.8.2 → snowflake_cli-3.9.0}/src/snowflake/cli/_plugins/cortex/constants.py

@@ -14,4 +14,5 @@
 
 from snowflake.cli._plugins.cortex.types import Model
 
-DEFAULT_MODEL: Model = Model("snowflake-arctic")
+DEFAULT_MODEL: Model = Model("llama3.1-70b")
+DEFAULT_BACKEND = "rest"

{snowflake_cli-3.8.2 → snowflake_cli-3.9.0}/src/snowflake/cli/_plugins/cortex/manager.py

@@ -32,43 +32,103 @@ from snowflake.cli.api.secure_path import SecurePath
 from snowflake.cli.api.sql_execution import SqlExecutionMixin
 from snowflake.connector import ProgrammingError
 from snowflake.connector.cursor import DictCursor
+from snowflake.core._root import Root
+from snowflake.core.cortex.inference_service import CortexInferenceService
+from snowflake.core.cortex.inference_service._generated.models import CompleteRequest
+from snowflake.core.cortex.inference_service._generated.models.complete_request_messages_inner import (
+    CompleteRequestMessagesInner,
+)
 
 log = logging.getLogger(__name__)
 
 
+class ResponseParseError(Exception):
+    """This exception is raised when the server response cannot be parsed."""
+
+    pass
+
+
+class MidStreamError(Exception):
+    """The SSE (Server-sent Event) stream can contain error messages in the middle of the stream,
+    using the “error” event type. This exception is raised when there is such a mid-stream error."""
+
+    def __init__(
+        self,
+        reason: Optional[str] = None,
+    ) -> None:
+        message = ""
+        if reason is not None:
+            message = reason
+        super().__init__(message)
+
+
 class CortexManager(SqlExecutionMixin):
-    def complete_for_prompt(
+    def complete(
         self,
         text: Text,
         model: Model,
+        is_file_input: bool = False,
     ) -> str:
-        query = f"""\
+        if not is_file_input:
+            query = f"""\
+                SELECT SNOWFLAKE.CORTEX.COMPLETE(
+                    '{model}',
+                    '{self._escape_input(text)}'
+                ) AS CORTEX_RESULT;"""
+            return self._query_cortex_result_str(query)
+        else:
+            query = f"""\
             SELECT SNOWFLAKE.CORTEX.COMPLETE(
                 '{model}',
-                '{self._escape_input(text)}'
+                PARSE_JSON('{self._escape_input(text)}'),
+                {{}}
             ) AS CORTEX_RESULT;"""
-        return self._query_cortex_result_str(query)
+            raw_result = self._query_cortex_result_str(query)
+            json_result = json.loads(raw_result)
+            return self._extract_text_result_from_json_result(
+                lambda: json_result["choices"][0]["messages"]
+            )
 
-    def complete_for_conversation(
+    def make_rest_complete_request(
         self,
-        conversation_json_file: SecurePath,
         model: Model,
-    ) -> str:
-        json_content = conversation_json_file.read_text(
-            file_size_limit_mb=DEFAULT_SIZE_LIMIT_MB
-        )
-        query = f"""\
-            SELECT SNOWFLAKE.CORTEX.COMPLETE(
-                '{model}',
-                PARSE_JSON('{self._escape_input(json_content)}'),
-                {{}}
-            ) AS CORTEX_RESULT;"""
-        raw_result = self._query_cortex_result_str(query)
-        json_result = json.loads(raw_result)
-        return self._extract_text_result_from_json_result(
-            lambda: json_result["choices"][0]["messages"]
+        prompt: Text,
+    ) -> CompleteRequest:
+        return CompleteRequest(
+            model=str(model),
+            messages=[CompleteRequestMessagesInner(content=str(prompt))],
+            stream=True,
         )
 
+    def rest_complete(
+        self,
+        text: Text,
+        model: Model,
+        root: "Root",
+    ) -> str:
+        complete_request = self.make_rest_complete_request(model=model, prompt=text)
+        cortex_inference_service = CortexInferenceService(root=root)
+        try:
+            raw_resp = cortex_inference_service.complete(
+                complete_request=complete_request
+            )
+        except Exception as e:
+            raise
+        result = ""
+        for event in raw_resp.events():
+            try:
+                parsed_resp = json.loads(event.data)
+            except json.JSONDecodeError:
+                raise ResponseParseError("Server response cannot be parsed")
+            try:
+                result += parsed_resp["choices"][0]["delta"]["content"]
+            except (json.JSONDecodeError, KeyError, IndexError):
+                if parsed_resp.get("error"):
+                    raise MidStreamError(reason=event.data)
+            else:
+                pass
+        return result
+
     def extract_answer_from_source_document(
         self,
         source_document: SourceDocument,
@@ -170,7 +230,7 @@ class CortexManager(SqlExecutionMixin):
 
     @staticmethod
     def _extract_text_result_from_json_result(
-        extract_function: Callable[[], str]
+        extract_function: Callable[[], str],
     ) -> str:
         try:
             return extract_function()

snowflake_cli-3.9.0/src/snowflake/cli/_plugins/dbt/__init__.py

@@ -0,0 +1,13 @@
+# Copyright (c) 2025 Snowflake Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

snowflake_cli-3.9.0/src/snowflake/cli/_plugins/dbt/commands.py

@@ -0,0 +1,187 @@
+# Copyright (c) 2025 Snowflake Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import logging
+from typing import Optional
+
+import typer
+from click import types
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from snowflake.cli._plugins.dbt.constants import (
+    DBT_COMMANDS,
+    OUTPUT_COLUMN_NAME,
+    PROFILES_FILENAME,
+    RESULT_COLUMN_NAME,
+)
+from snowflake.cli._plugins.dbt.manager import DBTManager
+from snowflake.cli._plugins.object.command_aliases import add_object_command_aliases
+from snowflake.cli._plugins.object.commands import scope_option
+from snowflake.cli.api.commands.decorators import global_options_with_connection
+from snowflake.cli.api.commands.flags import identifier_argument, like_option
+from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
+from snowflake.cli.api.constants import ObjectType
+from snowflake.cli.api.exceptions import CliError
+from snowflake.cli.api.feature_flags import FeatureFlag
+from snowflake.cli.api.identifiers import FQN
+from snowflake.cli.api.output.types import (
+    CommandResult,
+    MessageResult,
+    QueryResult,
+)
+from snowflake.cli.api.secure_path import SecurePath
+
+app = SnowTyperFactory(
+    name="dbt",
+    help="Manages dbt on Snowflake projects",
+    is_hidden=FeatureFlag.ENABLE_DBT.is_disabled,
+)
+log = logging.getLogger(__name__)
+
+
+DBTNameArgument = identifier_argument(sf_object="DBT Project", example="my_pipeline")
+
+# in passthrough commands we need to support that user would either provide the name of dbt object or name of dbt
+# command, in which case FQN validation could fail
+DBTNameOrCommandArgument = identifier_argument(
+    sf_object="DBT Project", example="my_pipeline", click_type=types.StringParamType()
+)
+
+add_object_command_aliases(
+    app=app,
+    object_type=ObjectType.DBT_PROJECT,
+    name_argument=DBTNameArgument,
+    like_option=like_option(
+        help_example='`list --like "my%"` lists all dbt projects that begin with “my”'
+    ),
+    scope_option=scope_option(help_example="`list --in database my_db`"),
+    ommit_commands=["drop", "create", "describe"],
+)
+
+
+@app.command(
+    "deploy",
+    requires_connection=True,
+)
+def deploy_dbt(
+    name: FQN = DBTNameArgument,
+    source: Optional[str] = typer.Option(
+        help="Path to directory containing dbt files to deploy. Defaults to current working directory.",
+        show_default=False,
+        default=None,
+    ),
+    profiles_dir: Optional[str] = typer.Option(
+        help=f"Path to directory containing {PROFILES_FILENAME}. Defaults to directory provided in --source or current working directory",
+        show_default=False,
+        default=None,
+    ),
+    force: Optional[bool] = typer.Option(
+        False,
+        help="Overwrites conflicting files in the project, if any.",
+    ),
+    **options,
+) -> CommandResult:
+    """
+    Copy dbt files and either recreate dbt on Snowflake if `--force` flag is
+    provided; or create a new one if it doesn't exist; or update files and
+    create a new version if it exists.
+    """
+    project_path = SecurePath(source) if source is not None else SecurePath.cwd()
+    profiles_dir_path = SecurePath(profiles_dir) if profiles_dir else project_path
+    return QueryResult(
+        DBTManager().deploy(
+            name,
+            project_path.resolve(),
+            profiles_dir_path.resolve(),
+            force=force,
+        )
+    )
+
+
+dbt_execute_app = SnowTyperFactory(
+    name="execute",
+    help="Execute a dbt command on Snowflake. Subcommand name and all "
+    "parameters following it will be passed over to dbt.",
+    subcommand_metavar="DBT_COMMAND",
+)
+app.add_typer(dbt_execute_app)
+
+
+@dbt_execute_app.callback()
+@global_options_with_connection
+def before_callback(
+    name: str = DBTNameOrCommandArgument,
+    run_async: Optional[bool] = typer.Option(
+        False, help="Run dbt command asynchronously and check it's result later."
+    ),
+    **options,
+):
+    """Handles global options passed before the command and takes pipeline name to be accessed through child context later"""
+    pass
+
+
+for cmd in DBT_COMMANDS:
+
+    @dbt_execute_app.command(
+        name=cmd,
+        requires_connection=False,
+        requires_global_options=False,
+        context_settings={"allow_extra_args": True, "ignore_unknown_options": True},
+        help=f"Execute {cmd} command on Snowflake. Command name and all parameters following it will be passed over to dbt.",
+        add_help_option=False,
+    )
+    def _dbt_execute(
+        ctx: typer.Context,
+    ) -> CommandResult:
+        dbt_cli_args = ctx.args
+        dbt_command = ctx.command.name
+        name = FQN.from_string(ctx.parent.params["name"])
+        run_async = ctx.parent.params["run_async"]
+        execute_args = (dbt_command, name, run_async, *dbt_cli_args)
+        dbt_manager = DBTManager()
+
+        if run_async is True:
+            result = dbt_manager.execute(*execute_args)
+            return MessageResult(
+                f"Command submitted. You can check the result with `snow sql -q \"select execution_status from table(information_schema.query_history_by_user()) where query_id in ('{result.sfqid}');\"`"
+            )
+
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            transient=True,
+        ) as progress:
+            progress.add_task(description=f"Executing 'dbt {dbt_command}'", total=None)
+
+            result = dbt_manager.execute(*execute_args)
+
+            try:
+                columns = [column.name for column in result.description]
+                success_column_index = columns.index(RESULT_COLUMN_NAME)
+                stdout_column_index = columns.index(OUTPUT_COLUMN_NAME)
+            except ValueError:
+                raise CliError("Malformed server response")
+            try:
+                is_success, output = [
+                    (row[success_column_index], row[stdout_column_index])
+                    for row in result
+                ][-1]
+            except IndexError:
+                raise CliError("No data returned from server")
+
+            if is_success is True:
+                return MessageResult(output)
+            else:
+                raise CliError(output)