init kill processes

kill-processes

···
+#!/usr/bin/env -S uv run --script --quiet
+# /// script
+# requires-python = ">=3.12"
+# dependencies = ["textual"]
+# ///
+import os
+import signal
+import subprocess
+from textual.app import App, ComposeResult
+from textual.widgets import (
+    Header,
+    Footer,
+    Static,
+    Input,
+    ListView,
+    ListItem,
+    Label,
+    Button,
+)
+from textual.containers import VerticalScroll, Vertical, Container, Horizontal
+from textual.screen import ModalScreen
+
+MIN_PATTERN = int(os.environ.get("PROCESS_TUI_MIN_PATTERN", 3))
+MAX_RESULTS = int(os.environ.get("PROCESS_TUI_MAX_RESULTS", 30))
+
+
+class ProcessList(Static):
+    def compose(self) -> ComposeResult:
+        self.list_view = ListView()
+        yield self.list_view
+
+    def update_processes(self, pattern: str = ""):
+        if not pattern:
+            self.list_view.clear()
+            self.list_view.append(
+                ListItem(Label("Enter a pattern to search for processes."))
+            )
+            return
+        if len(pattern) < MIN_PATTERN:
+            self.list_view.clear()
+            self.list_view.append(
+                ListItem(Label(f"Pattern must be at least {MIN_PATTERN} characters."))
+            )
+            return
+        try:
+            result = subprocess.run(
+                ["pgrep", "-f", pattern], capture_output=True, text=True
+            )
+            pids = [pid for pid in result.stdout.strip().split() if pid]
+        except FileNotFoundError:
+            self.list_view.clear()
+            self.list_view.append(ListItem(Label("pgrep not found")))
+            return
+        if len(pids) > MAX_RESULTS:
+            self.list_view.clear()
+            self.list_view.append(
+                ListItem(
+                    Label(
+                        f"Too many results ({len(pids)}). Please refine your pattern or set PROCESS_TUI_MAX_RESULTS."
+                    )
+                )
+            )
+            return
+        self.list_view.clear()
+        if not pids:
+            self.list_view.append(ListItem(Label("No processes found.")))
+            return
+        for pid in pids:
+            try:
+                cmd = subprocess.run(
+                    ["ps", "-p", pid, "-o", "args="], capture_output=True, text=True
+                ).stdout.strip()
+                item = ListItem(Label(f"[b]PID:[/b] {pid}\n[dim]{cmd}[/dim]"))
+            except Exception:
+                item = ListItem(
+                    Label(f"[b]PID:[/b] {pid}\n[red](unable to get command)[/red]")
+                )
+            self.list_view.append(item)
+
+
+class ConfirmKillScreen(ModalScreen[bool]):
+    def __init__(self, pattern: str):
+        super().__init__()
+        self.pattern = pattern
+
+    def compose(self) -> ComposeResult:
+        with Container():
+            yield Label(f"Kill all processes matching '{self.pattern}'?", id="question")
+            with Horizontal():
+                yield Button("No", id="no", variant="primary")
+                yield Button("Yes", id="yes", variant="error")
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        self.dismiss(event.button.id == "yes")
+
+
+class ProcessTUI(App):
+    CSS = """
+    VerticalScroll {
+        padding: 1;
+    }
+    Input {
+        margin: 1;
+    }
+    ListView {
+        margin: 1;
+    }
+    #question {
+        content-align: center middle;
+        margin-bottom: 1;
+    }
+    """
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        with Vertical():
+            self.input = Input(
+                placeholder="Enter pattern to match processes (press Enter to kill)"
+            )
+            yield self.input
+            with VerticalScroll():
+                self.proc_list = ProcessList()
+                yield self.proc_list
+        yield Footer()
+
+    def on_mount(self):
+        self.proc_list.update_processes()
+
+    def on_input_submitted(self, event: Input.Submitted):
+        pattern = event.value.strip()
+        if not pattern or len(pattern) < MIN_PATTERN:
+            return
+
+        def handle_confirm(result: bool | None):
+            if result:
+                try:
+                    result = subprocess.run(
+                        ["pgrep", "-f", pattern], capture_output=True, text=True
+                    )
+                    pids = [int(pid) for pid in result.stdout.strip().split() if pid]
+                    for pid in pids:
+                        try:
+                            os.kill(pid, signal.SIGTERM)
+                        except Exception:
+                            pass
+                except Exception:
+                    pass
+            self.input.disabled = False
+            self.proc_list.update_processes()
+
+        self.input.disabled = True
+        self.push_screen(ConfirmKillScreen(pattern), handle_confirm)
+
+    def on_input_changed(self, event: Input.Changed):
+        if not self.input.disabled:
+            self.proc_list.update_processes(event.value.strip())
+
+
+if __name__ == "__main__":
+    ProcessTUI().run()