add checksums and installation security

Author: bishoy-at-pieces

install_pieces_cli.ps1

@@ -36,6 +36,7 @@ sentry-sdk = "^2.34.1"
 
 [tool.poetry.group.dev.dependencies]
 pytest = "^8.0.0"
+pytest-xdist = "^3.5.0"
 pyinstaller = "^6.13.0"
 requests = "^2.31.0"
 pytest-asyncio = "^1.0.0"
@@ -52,9 +53,23 @@ build-backend = "poetry.core.masonry.api"
 pieces = "pieces.app:main"
 
 [tool.pytest.ini_options]
-asyncio_mode = "strict"
-asyncio_default_fixture_loop_scope = "function"
 testpaths = ["tests"]
 python_files = ["test_*.py", "*_test.py"]
 python_classes = ["Test*"]
 python_functions = ["test_*"]
+asyncio_mode = "strict"
+asyncio_default_fixture_loop_scope = "function"
+
+# Concurrent execution settings
+addopts = [
+    "--strict-markers",
+    "--tb=short",
+    "-ra",
+    "--showlocals",
+]
+
+# Logging for better debugging
+log_cli = true
+log_cli_level = "INFO"
+log_cli_format = "%(asctime)s [%(levelname)8s] %(name)s: %(message)s"
+log_cli_date_format = "%Y-%m-%d %H:%M:%S"

install_pieces_cli.sh

@@ -35,7 +35,43 @@ def _check_command_availability(command: str) -> bool:
 def _get_executable_location() -> Optional[Path]:
     """Get the location of the current pieces executable."""
     try:
-        return Path(os.path.abspath(sys.argv[0]))
+        # Method 1: Try sys.argv[0] if it looks like an executable path
+        if sys.argv and sys.argv[0]:
+            argv_path = Path(os.path.abspath(sys.argv[0]))
+            # If it's a Python file, we're likely running via python -m pieces
+            if argv_path.suffix in {".py", ".pyc"}:
+                # Try to find 'pieces' in PATH instead
+                pieces_exec = shutil.which("pieces")
+                if pieces_exec:
+                    return Path(pieces_exec)
+            else:
+                # Direct executable invocation
+                return argv_path
+
+        # Method 2: Try finding 'pieces' in PATH
+        pieces_exec = shutil.which("pieces")
+        if pieces_exec:
+            return Path(pieces_exec)
+
+        # Method 3: Check if we're in a known installation structure
+        # This handles cases where we're running from a venv or specific install location
+        current_file = Path(__file__).resolve()
+
+        # Check for installer method structure: ~/.pieces-cli/venv/lib/python*/site-packages/pieces/...
+        pieces_cli_dir = Path.home() / ".pieces-cli"
+        if pieces_cli_dir in current_file.parents:
+            wrapper_script = pieces_cli_dir / "pieces"
+            if wrapper_script.exists():
+                return wrapper_script
+
+        # Method 4: Look for pieces executable relative to current Python
+        python_dir = Path(sys.executable).parent
+        for name in ["pieces", "pieces.exe", "pieces.cmd"]:
+            candidate = python_dir / name
+            if candidate.exists():
+                return candidate
+
+        return None
     except Exception:
         return None
 

poetry.lock

@@ -16,7 +16,7 @@
 from pieces.gui import print_version_details
 from pieces import __version__
 from pieces.settings import Settings
-from pieces.help_structure import HelpBuilder
+from pieces.help_structure import CommandHelp, HelpBuilder
 
 
 class RunCommand(BaseCommand):
@@ -273,8 +273,14 @@ def get_help(self) -> str:
     def get_description(self) -> str:
         return "Update PiecesOS"
 
-    def get_examples(self) -> list[str]:
-        return ["pieces update"]
+    def get_examples(self) -> CommandHelp:
+        builder = HelpBuilder()
+
+        builder.section(
+            header="Update PiecesOS:", command_template="pieces update"
+        ).example("pieces update", "Update PiecesOS to the latest version")
+
+        return builder.build()
 
     def get_docs(self) -> str:
         return URLs.CLI_UPDATE_DOCS.value
@@ -284,7 +290,6 @@ def execute(self, **kwargs) -> int | CommandResult:
         return 0 if update_pieces_os() else 1
 
 
-
 class RestartPiecesOSCommand(BaseCommand):
     """Command to restart PiecesOS."""
 

pyproject.toml

@@ -80,15 +80,79 @@ class TestExecutableLocation:
 
     def test_finds_pieces_executable(self):
         """Test finding pieces executable using sys.argv[0]."""
-        with patch("sys.argv", ["/usr/local/bin/pieces", "manage", "status"]):
-            result = _get_executable_location()
-            assert result == Path("/usr/local/bin/pieces")
+        test_path = "/usr/local/bin/pieces"
+        with patch("sys.argv", [test_path, "manage", "status"]):
+            with patch("shutil.which", return_value=None):  # Disable PATH fallback
+                result = _get_executable_location()
+                # Convert expected path to absolute path for platform compatibility
+                expected = Path(os.path.abspath(test_path))
+                assert result == expected
 
     def test_executable_not_found(self):
-        """Test when sys.argv is empty."""
+        """Test when sys.argv is empty and no fallbacks work."""
         with patch("sys.argv", []):
-            result = _get_executable_location()
-            assert result is None
+            with patch("shutil.which", return_value=None):
+                with patch("pathlib.Path.exists", return_value=False):
+                    result = _get_executable_location()
+                    assert result is None
+
+    def test_finds_pieces_via_path(self):
+        """Test finding pieces executable via PATH when sys.argv[0] is a Python file."""
+        with patch("sys.argv", ["/path/to/python/script.py", "manage", "status"]):
+            with patch("shutil.which", return_value="/usr/local/bin/pieces"):
+                result = _get_executable_location()
+                assert result == Path("/usr/local/bin/pieces")
+
+    def test_finds_pieces_via_path_fallback(self):
+        """Test finding pieces executable via PATH as fallback."""
+        with patch("sys.argv", []):  # Empty sys.argv
+            with patch("shutil.which", return_value="/usr/local/bin/pieces"):
+                result = _get_executable_location()
+                assert result == Path("/usr/local/bin/pieces")
+
+    def test_finds_pieces_in_installer_structure(self):
+        """Test finding pieces in installer directory structure."""
+        installer_dir = Path.home() / ".pieces-cli"
+        wrapper_script = installer_dir / "pieces"
+
+        with patch("sys.argv", []):
+            with patch("shutil.which", return_value=None):
+                with patch(
+                    "pathlib.Path.__file__",
+                    str(
+                        installer_dir
+                        / "venv/lib/python3.11/site-packages/pieces/app.py"
+                    ),
+                ):
+                    with patch.object(wrapper_script, "exists", return_value=True):
+                        # Need to mock the Path constructor and parents
+                        mock_current_file = Mock()
+                        mock_current_file.parents = [
+                            installer_dir / "venv/lib/python3.11/site-packages/pieces",
+                            installer_dir / "venv/lib/python3.11/site-packages",
+                            installer_dir / "venv/lib/python3.11",
+                            installer_dir / "venv/lib",
+                            installer_dir / "venv",
+                            installer_dir,
+                            Path.home(),
+                        ]
+
+                        with patch(
+                            "pathlib.Path.resolve", return_value=mock_current_file
+                        ):
+                            result = _get_executable_location()
+                            assert result == wrapper_script
+
+    def test_finds_pieces_relative_to_python(self):
+        """Test finding pieces executable relative to current Python."""
+        python_dir = Path(sys.executable).parent
+        pieces_executable = python_dir / "pieces"
+
+        with patch("sys.argv", []):
+            with patch("shutil.which", return_value=None):
+                with patch.object(pieces_executable, "exists", return_value=True):
+                    result = _get_executable_location()
+                    assert result == pieces_executable
 
     def test_exception_handling(self):
         """Test exception handling during detection."""