macutility 0.1.0__py3-none-any.whl

app/main.py

@@ -0,0 +1,20 @@
+import sys
+
+from PySide6.QtWidgets import QApplication
+
+from app.ui.main_window import MainWindow
+
+
+def main():
+    app = QApplication(sys.argv)
+
+    window = MainWindow()
+    window.show()
+
+    sys.exit(
+        app.exec()
+    )
+
+
+if __name__ == "__main__":
+    main()

app/services/process_service.py

@@ -0,0 +1,169 @@
+import os
+from typing import Any
+
+import psutil
+
+from app.utils.protected_processes import (
+    PROTECTED_APP_KEYWORDS,
+    PROTECTED_PROCESS_NAMES,
+)
+
+
+class ProcessService:
+    """
+    Service untuk membaca dan mengontrol proses macOS.
+    """
+
+    def __init__(self):
+        self.process_cache: dict[int, psutil.Process] = {}
+
+    # ---------------------------------------------------------
+    # Process List
+    # ---------------------------------------------------------
+
+    def get_processes(self) -> list[dict[str, Any]]:
+        processes = []
+
+        current_pids = set()
+
+        for process in psutil.process_iter(
+            [
+                "pid",
+                "ppid",
+                "name",
+                "username",
+                "memory_percent",
+                "status",
+            ]
+        ):
+            try:
+                pid = process.pid
+                current_pids.add(pid)
+
+                # Simpan object Process supaya sampling CPU
+                # tetap konsisten antar-refresh.
+                self.process_cache[pid] = process
+
+                info = process.info
+
+                name = info.get("name") or "Unknown"
+
+                # CPU sampling.
+                cpu = process.cpu_percent(interval=None)
+
+                memory = info.get("memory_percent") or 0.0
+
+                protected = self.is_protected(
+                    name,
+                    process,
+                )
+
+                processes.append(
+                    {
+                        "pid": pid,
+                        "ppid": info.get("ppid") or 0,
+                        "name": name,
+                        "username": info.get("username") or "",
+                        "cpu": cpu,
+                        "memory": memory,
+                        "status": info.get("status") or "",
+                        "protected": protected,
+                    }
+                )
+
+            except (
+                psutil.NoSuchProcess,
+                psutil.AccessDenied,
+                psutil.ZombieProcess,
+            ):
+                continue
+
+        # Hapus process yang sudah mati dari cache.
+        stale_pids = set(self.process_cache.keys()) - current_pids
+
+        for pid in stale_pids:
+            self.process_cache.pop(pid, None)
+
+        return processes
+
+    # ---------------------------------------------------------
+    # Protected Process
+    # ---------------------------------------------------------
+
+    @staticmethod
+    def is_protected(
+        name: str,
+        process: psutil.Process,
+    ) -> bool:
+
+        if name in PROTECTED_PROCESS_NAMES:
+            return True
+
+        for keyword in PROTECTED_APP_KEYWORDS:
+            if keyword.lower() in name.lower():
+                return True
+
+        # Jangan izinkan aplikasi membunuh dirinya sendiri.
+        try:
+            if process.pid == os.getpid():
+                return True
+
+        except Exception:
+            pass
+
+        return False
+
+    # ---------------------------------------------------------
+    # Kill Process
+    # ---------------------------------------------------------
+
+    def kill_process(
+        self,
+        pid: int,
+        force: bool = False,
+    ) -> tuple[bool, str]:
+
+        try:
+            process = psutil.Process(pid)
+
+            name = process.name()
+
+            # Protection check.
+            if self.is_protected(name, process):
+                return (
+                    False,
+                    f"Process '{name}' (PID {pid}) dilindungi.",
+                )
+
+            if force:
+                process.kill()
+            else:
+                process.terminate()
+
+            # Hapus dari cache.
+            self.process_cache.pop(pid, None)
+
+            return (
+                True,
+                f"Process '{name}' (PID {pid}) berhasil dihentikan.",
+            )
+
+        except psutil.NoSuchProcess:
+            self.process_cache.pop(pid, None)
+
+            return (
+                False,
+                f"Process PID {pid} sudah tidak ada.",
+            )
+
+        except psutil.AccessDenied:
+            return (
+                False,
+                f"Tidak punya permission untuk menghentikan PID {pid}.",
+            )
+
+        except Exception as error:
+            return (
+                False,
+                str(error),
+            )

app/ui/main_window.py

@@ -0,0 +1,517 @@
+from PySide6.QtCore import QTimer, Qt
+from PySide6.QtGui import QAction
+from PySide6.QtWidgets import (
+    QApplication,
+    QHBoxLayout,
+    QHeaderView,
+    QLabel,
+    QLineEdit,
+    QMainWindow,
+    QMessageBox,
+    QPushButton,
+    QProgressBar,
+    QTableWidget,
+    QTableWidgetItem,
+    QVBoxLayout,
+    QWidget,
+)
+
+import psutil
+
+from app.services.process_service import ProcessService
+
+
+class MainWindow(QMainWindow):
+
+    def __init__(self):
+        super().__init__()
+
+        self.setWindowTitle("Mac Utility")
+        self.resize(1100, 700)
+
+        self.process_service = ProcessService()
+
+        self.all_processes = []
+
+        self.setup_ui()
+        self.setup_timer()
+
+        self.refresh_system()
+        self.refresh_processes()
+
+    # ---------------------------------------------------------
+    # UI
+    # ---------------------------------------------------------
+
+    def setup_ui(self):
+
+        central_widget = QWidget()
+        self.setCentralWidget(central_widget)
+
+        main_layout = QVBoxLayout(central_widget)
+        main_layout.setContentsMargins(20, 20, 20, 20)
+        main_layout.setSpacing(15)
+
+        # -----------------------------------------------------
+        # Header
+        # -----------------------------------------------------
+
+        header_layout = QHBoxLayout()
+
+        title = QLabel("Mac Utility")
+        title.setObjectName("title")
+
+        subtitle = QLabel("System & Process Manager")
+
+        header_layout.addWidget(title)
+        header_layout.addWidget(subtitle)
+        header_layout.addStretch()
+
+        main_layout.addLayout(header_layout)
+
+        # -----------------------------------------------------
+        # System monitor
+        # -----------------------------------------------------
+
+        system_layout = QHBoxLayout()
+
+        # CPU
+
+        cpu_container = QVBoxLayout()
+
+        self.cpu_label = QLabel("CPU 0%")
+
+        self.cpu_progress = QProgressBar()
+        self.cpu_progress.setRange(0, 100)
+
+        cpu_container.addWidget(self.cpu_label)
+        cpu_container.addWidget(self.cpu_progress)
+
+        # RAM
+
+        ram_container = QVBoxLayout()
+
+        self.ram_label = QLabel("RAM 0%")
+
+        self.ram_progress = QProgressBar()
+        self.ram_progress.setRange(0, 100)
+
+        ram_container.addWidget(self.ram_label)
+        ram_container.addWidget(self.ram_progress)
+
+        system_layout.addLayout(cpu_container)
+        system_layout.addLayout(ram_container)
+
+        main_layout.addLayout(system_layout)
+
+        # -----------------------------------------------------
+        # Search
+        # -----------------------------------------------------
+
+        search_layout = QHBoxLayout()
+
+        self.search_input = QLineEdit()
+        self.search_input.setPlaceholderText(
+            "Search process..."
+        )
+
+        self.refresh_button = QPushButton("Refresh")
+
+        self.refresh_button.clicked.connect(
+            self.refresh_processes
+        )
+
+        search_layout.addWidget(self.search_input)
+        search_layout.addWidget(self.refresh_button)
+
+        main_layout.addLayout(search_layout)
+
+        self.search_input.textChanged.connect(
+            self.filter_processes
+        )
+
+        # -----------------------------------------------------
+        # Process table
+        # -----------------------------------------------------
+
+        self.process_table = QTableWidget()
+
+        self.process_table.setColumnCount(7)
+
+        self.process_table.setHorizontalHeaderLabels(
+            [
+                "PID",
+                "Process",
+                "CPU",
+                "RAM",
+                "Status",
+                "Protection",
+                "Action",
+            ]
+        )
+
+        self.process_table.setSortingEnabled(True)
+
+        self.process_table.setSelectionBehavior(
+            QTableWidget.SelectRows
+        )
+
+        self.process_table.setEditTriggers(
+            QTableWidget.NoEditTriggers
+        )
+
+        header = self.process_table.horizontalHeader()
+
+        header.setSectionResizeMode(
+            1,
+            QHeaderView.Stretch,
+        )
+
+        for column in [0, 2, 3, 4, 5, 6]:
+            header.setSectionResizeMode(
+                column,
+                QHeaderView.ResizeToContents,
+            )
+
+        main_layout.addWidget(self.process_table)
+
+        # -----------------------------------------------------
+        # Style
+        # -----------------------------------------------------
+
+        self.setStyleSheet(
+            """
+            QMainWindow {
+                background: #111827;
+            }
+
+            QWidget {
+                color: #e5e7eb;
+                font-size: 13px;
+            }
+
+            QLabel#title {
+                font-size: 24px;
+                font-weight: bold;
+            }
+
+            QLineEdit {
+                background: #1f2937;
+                border: 1px solid #374151;
+                border-radius: 6px;
+                padding: 8px;
+            }
+
+            QPushButton {
+                background: #374151;
+                border: none;
+                border-radius: 6px;
+                padding: 8px 14px;
+            }
+
+            QPushButton:hover {
+                background: #4b5563;
+            }
+
+            QTableWidget {
+                background: #111827;
+                alternate-background-color: #1f2937;
+                border: 1px solid #374151;
+                gridline-color: #374151;
+            }
+
+            QHeaderView::section {
+                background: #1f2937;
+                padding: 8px;
+                border: none;
+                font-weight: bold;
+            }
+
+            QProgressBar {
+                background: #1f2937;
+                border: none;
+                border-radius: 5px;
+                text-align: center;
+            }
+
+            QProgressBar::chunk {
+                background: #60a5fa;
+                border-radius: 5px;
+            }
+            """
+        )
+
+    # ---------------------------------------------------------
+    # Timer
+    # ---------------------------------------------------------
+
+    def setup_timer(self):
+
+        self.timer = QTimer(self)
+
+        self.timer.timeout.connect(
+            self.refresh_system
+        )
+
+        self.timer.timeout.connect(
+            self.refresh_processes
+        )
+
+        # Refresh setiap 2 detik.
+        self.timer.start(2000)
+
+    # ---------------------------------------------------------
+    # System
+    # ---------------------------------------------------------
+
+    def refresh_system(self):
+
+        cpu = psutil.cpu_percent(interval=None)
+
+        memory = psutil.virtual_memory()
+
+        ram = memory.percent
+
+        self.cpu_label.setText(
+            f"CPU  {cpu:.1f}%"
+        )
+
+        self.cpu_progress.setValue(
+            int(cpu)
+        )
+
+        self.ram_label.setText(
+            f"RAM  {ram:.1f}%"
+        )
+
+        self.ram_progress.setValue(
+            int(ram)
+        )
+
+    # ---------------------------------------------------------
+    # Processes
+    # ---------------------------------------------------------
+
+    def refresh_processes(self):
+
+        self.all_processes = (
+            self.process_service.get_processes()
+        )
+
+        self.filter_processes(
+            self.search_input.text()
+        )
+
+    def filter_processes(self, text: str):
+
+        search = text.lower().strip()
+
+        processes = self.all_processes
+
+        if search:
+            processes = [
+                process
+                for process in processes
+                if (
+                    search in process["name"].lower()
+                    or search
+                    in str(process["pid"])
+                )
+            ]
+
+        # CPU terbesar di atas.
+        processes = sorted(
+            processes,
+            key=lambda item: item["cpu"],
+            reverse=True,
+        )
+
+        self.process_table.setSortingEnabled(False)
+
+        self.process_table.setRowCount(
+            len(processes)
+        )
+
+        for row, process in enumerate(processes):
+
+            self.process_table.setItem(
+                row,
+                0,
+                QTableWidgetItem(
+                    str(process["pid"])
+                ),
+            )
+
+            self.process_table.setItem(
+                row,
+                1,
+                QTableWidgetItem(
+                    process["name"]
+                ),
+            )
+
+            cpu_item = QTableWidgetItem(
+                f'{process["cpu"]:.1f}%'
+            )
+
+            cpu_item.setTextAlignment(
+                Qt.AlignCenter
+            )
+
+            self.process_table.setItem(
+                row,
+                2,
+                cpu_item,
+            )
+
+            memory_item = QTableWidgetItem(
+                f'{process["memory"]:.1f}%'
+            )
+
+            memory_item.setTextAlignment(
+                Qt.AlignCenter
+            )
+
+            self.process_table.setItem(
+                row,
+                3,
+                memory_item,
+            )
+
+            self.process_table.setItem(
+                row,
+                4,
+                QTableWidgetItem(
+                    process["status"]
+                ),
+            )
+
+            protection = (
+                "🔒 Protected"
+                if process["protected"]
+                else "—"
+            )
+
+            self.process_table.setItem(
+                row,
+                5,
+                QTableWidgetItem(
+                    protection
+                ),
+            )
+
+            button = QPushButton(
+                "Protected"
+                if process["protected"]
+                else "Kill"
+            )
+
+            button.setEnabled(
+                not process["protected"]
+            )
+
+            button.clicked.connect(
+                lambda checked=False,
+                pid=process["pid"],
+                name=process["name"]:
+                    self.confirm_kill(pid, name)
+            )
+
+            self.process_table.setCellWidget(
+                row,
+                6,
+                button,
+            )
+
+        self.process_table.setSortingEnabled(True)
+
+    # ---------------------------------------------------------
+    # Kill
+    # ---------------------------------------------------------
+
+    def confirm_kill(
+        self,
+        pid: int,
+        name: str,
+    ):
+
+        dialog = QMessageBox(self)
+
+        dialog.setWindowTitle(
+            "Kill Process"
+        )
+
+        dialog.setText(
+            f"Apakah kamu yakin ingin menghentikan:\n\n"
+            f"{name}\n"
+            f"PID: {pid}"
+        )
+
+        dialog.setInformativeText(
+            "Gunakan Force Kill hanya jika process "
+            "tidak merespons."
+        )
+
+        normal_button = dialog.addButton(
+            "Kill",
+            QMessageBox.AcceptRole,
+        )
+
+        force_button = dialog.addButton(
+            "Force Kill",
+            QMessageBox.DestructiveRole,
+        )
+
+        dialog.addButton(
+            "Cancel",
+            QMessageBox.RejectRole,
+        )
+
+        dialog.exec()
+
+        clicked = dialog.clickedButton()
+
+        if clicked == normal_button:
+
+            self.execute_kill(
+                pid,
+                force=False,
+            )
+
+        elif clicked == force_button:
+
+            self.execute_kill(
+                pid,
+                force=True,
+            )
+
+    def execute_kill(
+        self,
+        pid: int,
+        force: bool,
+    ):
+
+        success, message = (
+            self.process_service.kill_process(
+                pid,
+                force,
+            )
+        )
+
+        if success:
+
+            QMessageBox.information(
+                self,
+                "Process Stopped",
+                message,
+            )
+
+        else:
+
+            QMessageBox.warning(
+                self,
+                "Unable to Stop Process",
+                message,
+            )
+
+        self.refresh_processes()

app/utils/protected_processes.py

@@ -0,0 +1,35 @@
+"""
+Daftar proses yang dilindungi.
+
+Proses di sini tidak akan bisa di-kill melalui aplikasi
+untuk mengurangi risiko membuat macOS tidak stabil.
+"""
+
+PROTECTED_PROCESS_NAMES = {
+    "kernel_task",
+    "launchd",
+    "WindowServer",
+    "loginwindow",
+    "systemuiserver",
+    "Finder",
+    "Dock",
+    "SystemUIServer",
+    "coreaudiod",
+    "coreduetd",
+    "mds",
+    "mds_stores",
+    "mdworker",
+    "mdworker_shared",
+    "cfprefsd",
+    "opendirectoryd",
+    "distnoted",
+    "notifyd",
+}
+
+# Aplikasi yang secara eksplisit tidak boleh disentuh.
+# Sesuai kebutuhan kita: Termius dan VS Code.
+PROTECTED_APP_KEYWORDS = {
+    "Termius",
+    "Visual Studio Code",
+    "Code Helper",
+}

macutility-0.1.0.dist-info/METADATA

@@ -0,0 +1,432 @@
+Metadata-Version: 2.5
+Name: macutility
+Version: 0.1.0
+Summary: A lightweight macOS desktop utility for system monitoring and process management.
+Project-URL: Homepage, https://github.com/codesyariah122/MacUtility
+Project-URL: Repository, https://github.com/codesyariah122/MacUtility
+Project-URL: Issues, https://github.com/codesyariah122/MacUtility/issues
+Author: Puji Ermanto
+License: MIT
+License-File: LICENSE
+Keywords: desktop,developer-tools,mac,macos,process-manager,system-monitor,utility
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: System :: Monitoring
+Classifier: Topic :: System :: Systems Administration
+Requires-Python: >=3.10
+Requires-Dist: psutil>=7.2.0
+Requires-Dist: pyside6>=6.11.0
+Description-Content-Type: text/markdown
+
+# MacUtility
+
+A lightweight macOS desktop utility built with Python and PySide6 for monitoring system resources and managing running processes.
+
+MacUtility is designed as a practical developer-oriented utility for macOS, with a focus on quickly identifying high CPU or memory usage and safely managing processes from a graphical interface.
+
+> 🚧 **Project Status:** Early Development / Pre-release
+
+---
+
+## Features
+
+### Process Manager
+
+Monitor running processes directly from a desktop interface.
+
+- View running processes
+- Display PID
+- Display process name
+- Monitor CPU usage
+- Monitor memory usage
+- View process status
+- Search processes by name or PID
+- Sort processes by CPU usage
+- Terminate processes
+- Force kill processes
+- Protected system processes
+
+### System Monitor
+
+Monitor basic system resources in real time.
+
+- CPU usage
+- Memory usage
+- Automatic refresh
+- Lightweight monitoring
+
+### Protected Processes
+
+MacUtility includes a protection layer to prevent accidental termination of important macOS processes.
+
+Protected processes include system components such as:
+
+- `kernel_task`
+- `launchd`
+- `WindowServer`
+- `loginwindow`
+- `systemuiserver`
+- `Finder`
+- `Dock`
+- `SystemUIServer`
+- `coreaudiod`
+- `coreduetd`
+- `mds`
+- `mds_stores`
+- `mdworker`
+- `mdworker_shared`
+- `cfprefsd`
+- `opendirectoryd`
+- `distnoted`
+- `notifyd`
+
+The application also protects selected applications that should remain available during development, including:
+
+- Termius
+- Visual Studio Code
+- Code Helper
+
+The protection system is intentionally conservative and may be expanded as the project evolves.
+
+---
+
+## Screenshots
+
+### Process Manager
+
+> Screenshot will be added as the UI evolves.
+
+---
+
+## Tech Stack
+
+MacUtility is built with:
+
+- **Python 3**
+- **PySide6** — desktop GUI framework
+- **psutil** — system and process monitoring
+
+### Architecture
+
+The project separates UI, process management, and utility logic:
+
+```text
+MacUtility/
+├── app/
+│   ├── __init__.py
+│   ├── main.py
+│   │
+│   ├── services/
+│   │   ├── __init__.py
+│   │   └── process_service.py
+│   │
+│   ├── ui/
+│   │   ├── __init__.py
+│   │   └── main_window.py
+│   │
+│   └── utils/
+│       ├── __init__.py
+│       └── protected_processes.py
+│
+├── .gitignore
+├── requirements.txt
+└── README.md
+```
+
+---
+
+## Requirements
+
+- macOS
+- Python 3.10+
+- pip
+- Virtual environment recommended
+
+PySide6 provides the desktop GUI, while psutil is responsible for accessing system and process information.
+
+---
+
+## Installation
+
+### 1. Clone the repository
+
+```bash
+git clone https://github.com/codesyariah122/MacUtility.git
+cd MacUtility
+```
+
+### 2. Create a virtual environment
+
+```bash
+python3 -m venv .venv
+```
+
+### 3. Activate the virtual environment
+
+```bash
+source .venv/bin/activate
+```
+
+### 4. Install dependencies
+
+```bash
+pip install -r requirements.txt
+```
+
+---
+
+## Running the Application
+
+From the project root:
+
+```bash
+python -m app.main
+```
+
+MacUtility should open as a desktop application.
+
+---
+
+## Development
+
+MacUtility is currently being developed incrementally.
+
+The current development milestone is:
+
+### V0.1.0
+
+- Process monitoring
+- CPU monitoring
+- Memory monitoring
+- Process search
+- Process sorting
+- Process termination
+- Force kill
+- Protected processes
+
+Future releases will expand the application into a broader macOS developer utility.
+
+---
+
+## Roadmap
+
+### V0.1.x — Process Manager
+
+- [x] CPU monitoring
+- [x] Memory monitoring
+- [x] Process list
+- [x] Process search
+- [x] Process sorting
+- [x] Process termination
+- [x] Force kill
+- [x] Protected processes
+- [x] Protected Termius
+- [x] Protected Visual Studio Code
+
+### V0.2.x — Dashboard
+
+- [ ] Improved system dashboard
+- [ ] Top CPU processes
+- [ ] Top memory processes
+- [ ] CPU usage indicators
+- [ ] Memory usage indicators
+- [ ] Process details
+- [ ] Background monitoring worker
+
+### V0.3.x — Disk Utilities
+
+- [ ] Disk usage monitoring
+- [ ] Large file finder
+- [ ] Cache inspection
+- [ ] Developer cache utilities
+- [ ] Storage overview
+
+### V0.4.x — Network Utilities
+
+- [ ] Network status
+- [ ] Network interface information
+- [ ] IP information
+- [ ] DNS utilities
+- [ ] Ping utility
+- [ ] Network diagnostics
+
+### V0.5.x — Port Manager
+
+- [ ] List listening ports
+- [ ] Identify processes using ports
+- [ ] Search ports
+- [ ] Terminate process by port
+- [ ] Port diagnostics
+
+Example:
+
+```text
+Port 8000
+
+PID       Process
+1234      php
+
+[ Kill Process ]
+```
+
+### V0.6.x — Developer Utilities
+
+Planned utilities for common development environments:
+
+- [ ] PHP process management
+- [ ] Node.js process management
+- [ ] Laravel utilities
+- [ ] Composer utilities
+- [ ] npm utilities
+- [ ] Yarn utilities
+- [ ] Flutter utilities
+- [ ] Android SDK utilities
+- [ ] Git utilities
+- [ ] SSH utilities
+
+### V0.7.x — Docker Utilities
+
+- [ ] Docker container overview
+- [ ] Container CPU usage
+- [ ] Container memory usage
+- [ ] Start/stop containers
+- [ ] Docker cleanup utilities
+- [ ] Docker resource overview
+
+### V0.8.x — macOS Integration
+
+- [ ] Menu bar application
+- [ ] macOS notifications
+- [ ] Launch at login
+- [ ] Native macOS application icon
+- [ ] Improved macOS permissions handling
+
+### V1.0.0 — Stable Release
+
+The goal for `1.0.0` is a stable, polished macOS developer utility with reliable system monitoring and a collection of useful developer-oriented tools.
+
+---
+
+## Safety
+
+MacUtility interacts directly with running processes.
+
+Process termination can cause:
+
+- Unsaved data loss
+- Application crashes
+- Interrupted development processes
+- Unexpected system behavior
+
+For this reason, MacUtility includes protected processes and confirmation dialogs before terminating processes.
+
+Use **Force Kill** only when a process is unresponsive and normal termination does not work.
+
+---
+
+## Why MacUtility?
+
+macOS already provides tools such as Activity Monitor and Terminal for process management.
+
+MacUtility aims to provide a simpler workflow for developers who frequently need to:
+
+1. Identify a process consuming excessive CPU or memory.
+2. Find its PID.
+3. Determine whether the process is safe to terminate.
+4. Stop it without opening Terminal.
+5. Access additional developer-oriented utilities from one application.
+
+For example:
+
+```text
+🔥 Firefox plugin-container
+
+CPU: 88%
+
+[ Kill ]
+```
+
+instead of manually running:
+
+```bash
+ps -Ao pid,pcpu,pmem,comm | sort -k2 -nr
+```
+
+and then:
+
+```bash
+kill -9 <PID>
+```
+
+---
+
+## Project Goals
+
+MacUtility aims to become a practical toolbox for macOS developers.
+
+The long-term goal is to bring frequently used commands and diagnostics into one lightweight desktop application.
+
+Instead of remembering multiple Terminal commands, developers should be able to perform common tasks through a single interface.
+
+---
+
+## Contributing
+
+Contributions, suggestions, and issue reports are welcome.
+
+Before submitting a pull request:
+
+1. Fork the repository.
+2. Create a feature branch.
+3. Make your changes.
+4. Test the application on macOS.
+5. Commit your changes.
+6. Open a pull request.
+
+Example:
+
+```bash
+git checkout -b feature/my-feature
+```
+
+---
+
+## License
+
+License information will be added before the first public release.
+
+---
+
+## Author
+
+**Puji Ermanto**
+
+GitHub:
+
+https://github.com/codesyariah122
+
+---
+
+## Repository
+
+GitHub:
+
+https://github.com/codesyariah122/MacUtility
+
+---
+
+## Status
+
+MacUtility is currently an active development project.
+
+The current version focuses on the foundation of the process manager and system monitoring functionality. APIs, architecture, UI, and features may change before the `1.0.0` stable release.

macutility-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+app/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+app/main.py,sha256=85pWCTUur8r9fbG5GnICyc5G34S4b2kplKqsqnYjz98,269
+app/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+app/services/process_service.py,sha256=cHYBHLTgClBffdS40bwQtbtYFX1rmBjoN1c_dtib34o,4349
+app/ui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+app/ui/main_window.py,sha256=hOgHQ-RLitEle4uvZliwmNgqj7tUh8nCCEC_-MSG0no,12062
+app/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+app/utils/protected_processes.py,sha256=6HBIL670i09dCpJjup7RCNgh1G7234bbye5nvPPcIJI,685
+macutility-0.1.0.dist-info/METADATA,sha256=C4IG3L6fyRZehZPcZtywsOTOu_AUF2i9mNtEuj7_ahU,9021
+macutility-0.1.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+macutility-0.1.0.dist-info/entry_points.txt,sha256=BfuLN8elGHoy_CkzVrmOz4NXRSzr5N46SzHeeaYeny8,45
+macutility-0.1.0.dist-info/licenses/LICENSE,sha256=SeRn2Z_Buqe-t5rOVIYna_nrKcs7KHTtVcQOrxhio2k,1069
+macutility-0.1.0.dist-info/RECORD,,

macutility-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

macutility-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+macutility = app.main:main

macutility-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Puji Ermanto
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.c