fly-ftui 0.1.0__tar.gz

fly_ftui-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Fly.io Community
+
+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.

fly_ftui-0.1.0/PKG-INFO

@@ -0,0 +1,55 @@
+Metadata-Version: 2.4
+Name: fly-ftui
+Version: 0.1.0
+Summary: A terminal UI for managing Fly.io machines
+Author: Fly.io Community
+License-File: LICENSE
+Keywords: cli,fly,flyio,textual,tui
+Classifier: Environment :: Console
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.12
+Requires-Dist: click>=8.3.1
+Requires-Dist: rich>=14.3.3
+Requires-Dist: textual>=8.1.1
+Description-Content-Type: text/markdown
+
+# ftui - Fly.io Terminal UI
+
+A Python-based TUI for managing your Fly.io machines.
+
+## Features
+- **List Machines:** View all machines in your current Fly app context.
+- **Real-time Logs:** Stream logs for specific machines.
+- **Scaling:** Quickly scale machine count and VM size.
+- **SSH Access:** Interactive shell access to your machines.
+- **Machine Control:** Start and stop machines directly from the UI.
+
+## Installation
+Requires [uv](https://github.com/astral-sh/uv).
+
+```bash
+uv tool install .
+```
+
+## Usage
+Run in a directory with a `fly.toml` file:
+
+```bash
+ftui
+```
+
+For development/testing without a live account:
+```bash
+ftui --mock
+```
+
+## Keybindings
+- `r`: Refresh machine list
+- `l`: View logs for selected machine
+- `s`: Scale app (count/VM size)
+- `h`: SSH into selected machine
+- `Ctrl+s`: Start selected machine
+- `Ctrl+x`: Stop selected machine
+- `q`: Quit / Back

fly_ftui-0.1.0/README.md

@@ -0,0 +1,38 @@
+# ftui - Fly.io Terminal UI
+
+A Python-based TUI for managing your Fly.io machines.
+
+## Features
+- **List Machines:** View all machines in your current Fly app context.
+- **Real-time Logs:** Stream logs for specific machines.
+- **Scaling:** Quickly scale machine count and VM size.
+- **SSH Access:** Interactive shell access to your machines.
+- **Machine Control:** Start and stop machines directly from the UI.
+
+## Installation
+Requires [uv](https://github.com/astral-sh/uv).
+
+```bash
+uv tool install .
+```
+
+## Usage
+Run in a directory with a `fly.toml` file:
+
+```bash
+ftui
+```
+
+For development/testing without a live account:
+```bash
+ftui --mock
+```
+
+## Keybindings
+- `r`: Refresh machine list
+- `l`: View logs for selected machine
+- `s`: Scale app (count/VM size)
+- `h`: SSH into selected machine
+- `Ctrl+s`: Start selected machine
+- `Ctrl+x`: Stop selected machine
+- `q`: Quit / Back

fly_ftui-0.1.0/build/lib/ftui/app.py

@@ -0,0 +1,252 @@
+import asyncio
+import os
+import sys
+from typing import Dict, Any, List
+
+from textual.app import App, ComposeResult
+from textual.widgets import Header, Footer, DataTable, Static, RichLog, Input, Label
+from textual.screen import Screen, ModalScreen
+from textual.containers import Container, Horizontal, Vertical
+from textual.binding import Binding
+
+from ftui.fly_client import FlyClient
+
+class MachineListScreen(Screen):
+    """Screen for listing and managing Fly machines."""
+    
+    BINDINGS = [
+        Binding("r", "refresh", "Refresh", show=True),
+        Binding("l", "view_logs", "Logs", show=True),
+        Binding("s", "scale", "Scale", show=True),
+        Binding("h", "ssh", "SSH", show=True),
+        Binding("ctrl+s", "start_machine", "Start", show=True),
+        Binding("ctrl+x", "stop_machine", "Stop", show=True),
+    ]
+
+    def __init__(self, fly_client: FlyClient):
+        super().__init__()
+        self.fly = fly_client
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        yield DataTable(id="machine-table", cursor_type="row")
+        yield Footer()
+
+    async def on_mount(self) -> None:
+        table = self.query_one(DataTable)
+        table.add_columns("ID", "Name", "State", "Region", "Image", "Created")
+        await self.action_refresh()
+        # Set a timer for periodic refresh
+        self.set_interval(10, self.action_refresh)
+
+    async def action_refresh(self) -> None:
+        """Fetch machine list and update table."""
+        table = self.query_one(DataTable)
+        try:
+            machines = await self.fly.list_machines()
+            table.clear()
+            for m in machines:
+                table.add_row(
+                    m.get("id", ""),
+                    m.get("name", ""),
+                    m.get("state", ""),
+                    m.get("region", ""),
+                    m.get("image", ""),
+                    m.get("created_at", "")[:19] # Truncate timestamp
+                )
+        except Exception as e:
+            self.notify(f"Error fetching machines: {e}", severity="error")
+
+    def get_selected_machine(self) -> str:
+        """Get the ID of the selected machine in the table."""
+        table = self.query_one(DataTable)
+        if table.cursor_row is not None:
+            row = table.get_row_at(table.cursor_row)
+            return row[0]
+        return None
+
+    async def action_view_logs(self) -> None:
+        machine_id = self.get_selected_machine()
+        if machine_id:
+            self.app.push_screen(LogScreen(self.fly, machine_id))
+        else:
+            self.notify("No machine selected")
+
+    async def action_scale(self) -> None:
+        self.app.push_screen(ScaleDialog(self.fly))
+
+    async def action_ssh(self) -> None:
+        machine_id = self.get_selected_machine()
+        if not machine_id:
+            self.notify("No machine selected")
+            return
+
+        # We need to suspend the TUI to run an interactive shell
+        self.app.suspend_stdio()
+        try:
+            print(f"Connecting to {machine_id}...")
+            # Use os.system for simple handover to the interactive fly ssh command
+            cmd = f"fly ssh console -s -m {machine_id}"
+            if self.fly.mock:
+                 print(f"MOCK: {cmd}")
+                 input("Press Enter to return to FTUI...")
+            else:
+                os.system(cmd)
+        finally:
+            self.app.resume_stdio()
+
+    async def action_start_machine(self) -> None:
+        machine_id = self.get_selected_machine()
+        if machine_id:
+            try:
+                await self.fly.start_machine(machine_id)
+                self.notify(f"Machine {machine_id} started")
+                await self.action_refresh()
+            except Exception as e:
+                self.notify(f"Failed to start machine: {e}", severity="error")
+
+    async def action_stop_machine(self) -> None:
+        machine_id = self.get_selected_machine()
+        if machine_id:
+            try:
+                await self.fly.stop_machine(machine_id)
+                self.notify(f"Machine {machine_id} stopped")
+                await self.action_refresh()
+            except Exception as e:
+                self.notify(f"Failed to stop machine: {e}", severity="error")
+
+class LogScreen(Screen):
+    """Screen for viewing machine logs."""
+    
+    BINDINGS = [
+        Binding("q", "back", "Back", show=True),
+        Binding("c", "clear", "Clear", show=True),
+    ]
+
+    def __init__(self, fly_client: FlyClient, machine_id: str):
+        super().__init__()
+        self.fly = fly_client
+        self.machine_id = machine_id
+        self.process = None
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        yield RichLog(id="log-viewer", highlight=True, markup=True)
+        yield Footer()
+
+    async def on_mount(self) -> None:
+        log_viewer = self.query_one(RichLog)
+        log_viewer.write(f"Tail logs for machine [bold cyan]{self.machine_id}[/bold cyan]...")
+        
+        # Start log tailing
+        asyncio.create_task(self.stream_logs())
+
+    async def stream_logs(self):
+        log_viewer = self.query_one(RichLog)
+        
+        if self.fly.mock:
+            while True:
+                log_viewer.write(f"[{self.machine_id}] Simulated log message {random.randint(100,999)}")
+                await asyncio.sleep(1)
+                if self.is_current_screen is False:
+                    break
+            return
+
+        args = ["logs", "--instance", self.machine_id]
+        self.process = await asyncio.create_subprocess_exec(
+            "fly", *args,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.STDOUT
+        )
+        
+        while True:
+            line = await self.process.stdout.readline()
+            if not line:
+                break
+            log_viewer.write(line.decode().strip())
+
+    def action_back(self) -> None:
+        if self.process:
+            self.process.terminate()
+        self.app.pop_screen()
+
+    def action_clear(self) -> None:
+        self.query_one(RichLog).clear()
+
+class ScaleDialog(ModalScreen):
+    """Modal for scaling applications."""
+    
+    def compose(self) -> ComposeResult:
+        with Container(id="dialog"):
+            yield Label("Scale Application", id="title")
+            yield Label("Machine Count:")
+            yield Input(placeholder="Enter count (e.g. 3)", id="count-input")
+            yield Label("VM Size:")
+            yield Input(placeholder="Enter size (e.g. shared-cpu-1x)", id="vm-input")
+            with Horizontal():
+                yield Static(id="spacer")
+                yield Vertical(
+                     Horizontal(
+                        Static(" "),
+                        Static("[b]Enter[/b] to Apply, [b]Esc[/b] to Cancel", id="help-text"),
+                        classes="dialog-buttons"
+                     )
+                )
+
+    def on_key(self, event) -> None:
+        if event.key == "escape":
+            self.app.pop_screen()
+
+    async def on_input_submitted(self, event: Input.Submitted) -> None:
+        count_val = self.query_one("#count-input", Input).value
+        vm_val = self.query_one("#vm-input", Input).value
+        
+        fly = FlyClient() # Re-using FlyClient
+        
+        try:
+            if count_val:
+                await fly.scale_count(int(count_val))
+                self.notify(f"Scaling count to {count_val}...")
+            
+            if vm_val:
+                await fly.scale_vm(vm_val)
+                self.notify(f"Scaling VM size to {vm_val}...")
+                
+            self.app.pop_screen()
+        except Exception as e:
+            self.notify(f"Scale error: {e}", severity="error")
+
+class FTUI(App):
+    """Main Fly.io TUI application."""
+    
+    CSS = """
+    #dialog {
+        width: 40;
+        height: auto;
+        border: thick $primary;
+        background: $surface;
+        padding: 1 2;
+        align: center middle;
+    }
+    #title {
+        text-align: center;
+        width: 100%;
+        margin-bottom: 1;
+        background: $primary;
+        color: $on-primary;
+    }
+    .dialog-buttons {
+        margin-top: 1;
+    }
+    #spacer {
+        width: 1fr;
+    }
+    """
+
+    def on_mount(self) -> None:
+        self.fly = FlyClient()
+        self.push_screen(MachineListScreen(self.fly))
+
+if __name__ == "__main__":
+    app = FTUI()
+    app.run()

fly_ftui-0.1.0/build/lib/ftui/fly_client.py

@@ -0,0 +1,107 @@
+import json
+import asyncio
+import os
+import random
+from typing import List, Dict, Any, Optional
+
+class FlyClient:
+    """Wrapper for flyctl commands."""
+    
+    def __init__(self, mock: bool = False):
+        self.mock = mock or os.getenv("FTUI_MOCK") == "1"
+
+    async def _run(self, args: List[str]) -> str:
+        """Run a flyctl command and return its output."""
+        if self.mock:
+            return await self._mock_run(args)
+        
+        proc = await asyncio.create_subprocess_exec(
+            "fly", *args,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE
+        )
+        stdout, stderr = await proc.communicate()
+        
+        if proc.returncode != 0:
+            raise Exception(f"flyctl error: {stderr.decode()}")
+        
+        return stdout.decode()
+
+    async def _mock_run(self, args: List[str]) -> str:
+        """Simulate flyctl command outputs."""
+        await asyncio.sleep(0.1)  # Simulate network latency
+        
+        cmd = " ".join(args)
+        if "machines list" in cmd and "--json" in cmd:
+            return json.dumps([
+                {
+                    "id": "148ed106c62289",
+                    "name": "gentle-sun-42",
+                    "state": "started",
+                    "region": "ams",
+                    "image": "flyio/hellofly:latest",
+                    "created_at": "2023-10-01T12:00:00Z"
+                },
+                {
+                    "id": "7811d615b04489",
+                    "name": "bitter-cloud-12",
+                    "state": "stopped",
+                    "region": "ams",
+                    "image": "flyio/hellofly:latest",
+                    "created_at": "2023-10-02T10:00:00Z"
+                },
+                {
+                    "id": "9080e21fb54287",
+                    "name": "patient-field-77",
+                    "state": "started",
+                    "region": "lhr",
+                    "image": "flyio/hellofly:latest",
+                    "created_at": "2023-10-03T08:30:00Z"
+                }
+            ])
+        
+        if "scale show" in cmd and "--json" in cmd:
+            return json.dumps({
+                "ProcessGroup": "app",
+                "Count": 3,
+                "CPUs": 1,
+                "Memory": 256,
+                "VMSize": "shared-cpu-1x"
+            })
+            
+        return ""
+
+    async def list_machines(self) -> List[Dict[str, Any]]:
+        """List machines for the current app."""
+        output = await self._run(["machines", "list", "--json"])
+        if not output.strip():
+            return []
+        return json.loads(output)
+
+    async def get_scale(self) -> Dict[str, Any]:
+        """Get scaling information for the current app."""
+        # Using machine list to infer count and VM size as 'scale show' can be complex to parse
+        # but let's try 'scale show --json' if supported or mock it.
+        try:
+            output = await self._run(["scale", "show", "--json"])
+            return json.loads(output)
+        except:
+            # Fallback for older flyctl versions or if json output is not available
+            machines = await self.list_machines()
+            return {"Count": len(machines), "VMSize": "unknown"}
+
+    async def scale_count(self, count: int):
+        """Scale the machine count."""
+        await self._run(["scale", "count", str(count), "--yes"])
+
+    async def scale_vm(self, size: str):
+        """Scale the VM size."""
+        await self._run(["scale", "vm", size, "--yes"])
+
+    async def stop_machine(self, machine_id: str):
+        """Stop a specific machine."""
+        await self._run(["machine", "stop", machine_id])
+
+    async def start_machine(self, machine_id: str):
+        """Start a specific machine."""
+        await self._run(["machine", "start", machine_id])

fly_ftui-0.1.0/build/lib/ftui/main.py

@@ -0,0 +1,17 @@
+import click
+import os
+from ftui.app import FTUI
+from ftui.fly_client import FlyClient
+
+@click.command()
+@click.option("--mock", is_flag=True, help="Use mock flyctl for development")
+def main(mock: bool):
+    """Fly.io Terminal UI (ftui)"""
+    if mock:
+        os.environ["FTUI_MOCK"] = "1"
+    
+    app = FTUI()
+    app.run()
+
+if __name__ == "__main__":
+    main()

fly_ftui-0.1.0/main.py

@@ -0,0 +1,6 @@
+def main():
+    print("Hello from ftui!")
+
+
+if __name__ == "__main__":
+    main()

fly_ftui-0.1.0/pyproject.toml

@@ -0,0 +1,31 @@
+[project]
+name = "fly-ftui"
+version = "0.1.0"
+description = "A terminal UI for managing Fly.io machines"
+readme = "README.md"
+requires-python = ">=3.12"
+authors = [
+    { name = "Fly.io Community" }
+]
+keywords = ["fly", "flyio", "tui", "textual", "cli"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Environment :: Console",
+]
+dependencies = [
+    "textual>=8.1.1",
+    "rich>=14.3.3",
+    "click>=8.3.1",
+]
+
+[project.scripts]
+ftui = "ftui.main:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/ftui"]