PyPI - colabapi - Versions diffs - 0.2.0__tar.gz → 0.2.2__tar.gz - Mend

colabapi 0.2.0tar.gz → 0.2.2tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (42) hide show

{colabapi-0.2.0 → colabapi-0.2.2}/PKG-INFO RENAMED Viewed

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: colabapi
-Version: 0.2.0
+Version: 0.2.2
 Summary: Run and keep a Google Colab runtime alive, then reach its terminal from your own server, laptop, or Windows PC. A CLI for headless, persistent Colab sessions -- with Windows support the official CLI does not have.
 Author: lil-limbo
 License: MIT
@@ -18,6 +18,7 @@ Classifier: Operating System :: Microsoft :: Windows
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: System :: Distributed Computing
 Classifier: Topic :: Utilities
 Requires-Python: >=3.12
@@ -26,21 +27,22 @@ License-File: LICENSE
 Requires-Dist: click>=8.1
 Requires-Dist: rich>=13.0
 Requires-Dist: websocket-client>=1.8
+Requires-Dist: pyte>=0.8
 Requires-Dist: google-colab-cli>=0.6.0
 Dynamic: license-file
 # colabapi: a terminal for a persistent Google Colab runtime
-**Run Google Colab from your own terminal — on Linux, macOS, *and Windows* — keep the runtime alive after you close the browser, and reach its shell from any VPS or laptop.** `colabapi` is a small, open source command line tool that turns a Google Colab GPU/TPU session into something you can drive headlessly. Perfect for demos, MVPs, and long running jobs that must survive after the Colab web tab is gone.
+**Run Google Colab from your own terminal on Linux, macOS, *and Windows*. Keep the runtime alive after you close the browser, and reach its shell from any VPS or laptop.** `colabapi` is a small, open source command line tool (with an optional desktop window) that turns a Google Colab GPU/TPU session into something you can drive headlessly. Perfect for demos, MVPs, and long running jobs that must survive after the Colab web tab is gone.
 > **In one line:** `colabapi` gives you a persistent Colab terminal on your own machine, using Google's official, ban safe sign in and tunnel, and it never sees your Google password.
 **Two things you only get here:**
-- 🪟 **It works on Windows.** Google's official Colab CLI is [Linux and macOS only](#windows) — it fails on Windows before it can even parse a command. colabapi ships the compatibility layer that makes it run in PowerShell and CMD.
-- 🔌 **It survives a dropped connection.** Google's terminal sets no WebSocket keepalive and has no reconnect, so one blip ends your session. colabapi pings, reconnects with backoff, and keeps your running job alive on the VM. [How](#staying-alive-what-actually-kills-a-colab-session).
+* 🪟 **It works on Windows.** Google's official Colab CLI is [Linux and macOS only](#windows). It fails on Windows before it can even parse a command. colabapi ships the compatibility layer that makes it run in PowerShell and CMD, and it registers as a real Windows app with its own icon and Start menu entry.
+* 🔌 **It survives a dropped connection.** Google's terminal sets no WebSocket keepalive and has no reconnect, so one blip ends your session. colabapi pings, reconnects with backoff, and keeps your running job alive on the VM.
-<!-- Keywords: google colab terminal, colab cli, colab ssh, colab windows, colab powershell, persistent colab, keep colab alive, headless colab, run colab from terminal, colab gpu terminal, colab from vps, colab session keep alive -->
+<!-- Keywords: google colab terminal, colab cli, colab ssh, colab windows, colab powershell, persistent colab, keep colab alive, headless colab, run colab from terminal, colab gpu terminal, colab from vps, colab session keep alive, colab gui -->
 ---
@@ -48,37 +50,38 @@ Dynamic: license-file
 Google Colab is fantastic free (and paid) GPU/TPU compute, but it only lives inside a browser tab. Close the tab or lose your connection and the session can go with it. That makes it awkward to:
-- **demo an MVP** that needs a GPU without renting a server,
-- **reach the runtime from a VPS** or a headless box,
-- **register it as a background service** that stays up, or
-- **watch CPU / GPU / RAM** from a normal terminal.
+* **demo an MVP** that needs a GPU without renting a server,
+* **reach the runtime from a VPS** or a headless box,
+* **register it as a background service** that stays up, or
+* **watch CPU / GPU / RAM** from a normal terminal.
-`colabapi` solves this by wrapping **Google's official [`google-colab-cli`](https://github.com/googlecolab/google-colab-cli)** with a friendly single command, a systemd service, a runtime picker, a live resource monitor, and a session time display. You sign in through Google's own browser flow; `colabapi` connects over Google's sanctioned tunnel.
+`colabapi` solves this by wrapping **Google's official [`google-colab-cli`](https://github.com/googlecolab/google-colab-cli)** with a friendly single command, a graphical window, a systemd service, a runtime picker, a live resource monitor, and a session time display. You sign in through Google's own browser flow; `colabapi` connects over Google's sanctioned tunnel.
 ## Features
-- 🪟 **Works on Windows** (PowerShell + CMD), which Google's own CLI does not. Registers as real installed software.
-- 🔌 **Reconnects instead of dying.** WebSocket keepalive pings, exponential backoff, and your work keeps running on the VM across the drop.
-- 🔐 **Browser sign in, no password handling.** Authentication happens in Google's own login flow (including 2FA / device checks). `colabapi` never asks for, stores, or transmits your Google credentials.
-- 💻 **Real terminal into the runtime.** `colabapi shell` drops you into a live shell on the Colab VM. `colabapi repl` gives you a Python REPL.
-- 🎛 **Runtime picker.** List CPU / T4 / L4 / G4 / A100 / H100 / TPU options; paid tier runtimes are clearly flagged as unavailable on a free account.
-- 📈 **Live CPU / GPU / RAM monitor.** `colabapi monitor` streams runtime stats to your terminal (psutil + `nvidia-smi`).
-- ⏱ **Session time display.** See uptime and an estimate of how long before Colab's max lifetime cap.
-- ♻️ **Keepalive that stays up.** Runs Google's own keepalive daemon — and restarts it when it dies, which it otherwise does silently.
-- 🧩 **Runs as a background service.** systemd on Linux, a Scheduled Task on Windows, so your session survives logout and reboot.
-- 🔎 **Inspectable & MIT licensed.** Read every line. Nothing phones home.
+* 🖥 **A desktop app, not just a CLI.** `colabapi ui` opens a clean graphical window (white, minimal, works on Linux and Windows) with live CPU / RAM / GPU / VRAM graphs, a session list, and a **real terminal built into the window** — the shell, sign-in, runtime allocation and everything else run *inside it*, not in a terminal it throws you out to. On Windows it opens straight from the Start menu and the app list.
+* 🪟 **Works on Windows** (PowerShell + CMD), which Google's own CLI does not. Registers as real installed software with its own logo.
+* 🔌 **Reconnects instead of dying.** WebSocket keepalive pings, exponential backoff, and your work keeps running on the VM across the drop.
+* 🔐 **Browser sign in, no password handling.** Authentication happens in Google's own login flow (including 2FA / device checks). `colabapi` never asks for, stores, or transmits your Google credentials. `colabapi logout` signs you out again in one command.
+* 💻 **Real terminal into the runtime.** `colabapi shell` drops you into a live shell on the Colab VM. `colabapi repl` gives you a Python REPL.
+* 🎛 **Runtime picker.** List CPU / T4 / L4 / G4 / A100 / H100 / TPU options; paid tier runtimes are clearly flagged as unavailable on a free account.
+* 📈 **Live CPU / GPU / RAM monitor.** `colabapi monitor` streams runtime stats to your terminal (psutil + `nvidia-smi`).
+* ⏱ **Session time display.** See uptime and an estimate of how long before Colab's max lifetime cap.
+* ♻️ **Keepalive that stays up.** Runs Google's own keepalive daemon and restarts it when it dies, which it otherwise does silently.
+* 🧩 **Runs as a background service.** systemd on Linux, a Scheduled Task on Windows, so your session survives logout and reboot.
+* 🔎 **Inspectable & MIT licensed.** Read every line. Nothing phones home.
 ## How it works
 ```
 you  >  colabapi (this tool)  >  colab_cli (Google's official CLI)  >  Google's tunnel  >  your Colab runtime (GPU/TPU VM)
-colabapi adds: Windows support, auto-reconnect, keepalive supervision,
-               runtime picker, monitor, session timer, background service
+colabapi adds: Windows support, auto-reconnect, keepalive supervision, a desktop
+               window, runtime picker, monitor, session timer, background service
 colabapi never handles your Google password
 ```
-`colabapi` is an **orchestration and reliability layer**. The heavy lifting — OAuth sign in, allocating the runtime, and the encrypted tunnel — is delegated to Google's first party CLI, which is the safe, supported way to do this. We do not reimplement any of it; we make it run where it otherwise cannot, and keep it running when it otherwise would not.
+`colabapi` is an **orchestration and reliability layer**. The heavy lifting (OAuth sign in, allocating the runtime, and the encrypted tunnel) is delegated to Google's first party CLI, which is the safe, supported way to do this. We do not reimplement any of it; we make it run where it otherwise cannot, and keep it running when it otherwise would not.
 ## Install
@@ -93,17 +96,17 @@ pipx install colabapi
 <a name="windows"></a>
 ### Windows (PowerShell or CMD)
-> **Google's official Colab CLI does not support Windows at all** — the docs say Linux and macOS only, and on Windows it raises `ImportError: No module named 'termios'` before it can parse a single command. **colabapi fixes that.** It ships a compatibility layer that supplies the POSIX pieces Windows lacks, so Google's CLI runs here unmodified — we patch nothing inside it, so their updates keep working.
+> **Google's official Colab CLI does not support Windows at all.** The docs say Linux and macOS only, and on Windows it raises `ImportError: No module named 'termios'` before it can parse a single command. **colabapi fixes that.** It ships a compatibility layer that supplies the POSIX pieces Windows lacks, so Google's CLI runs here unmodified. We patch nothing inside it, so their updates keep working.
 **One line, in PowerShell:**
 ```powershell
-irm https://raw.githubusercontent.com/lil-limbo/colabapi/main/scripts/install.ps1 | iex
+irm https://raw.githubusercontent.com/lil-limbo/colabapi/v0.2.1/scripts/install.ps1 | iex
 ```
-That installs Python's `pipx` if needed, installs colabapi, fixes your `PATH`, and registers it with Windows. No administrator rights required.
+That finds Python 3.12+ (and offers to install it with winget if you have none), installs Python's `pipx` if needed, installs colabapi, fixes your `PATH`, and registers it with Windows. No administrator rights required. The URL is pinned to the released tag, so you can [read exactly what will run](https://github.com/lil-limbo/colabapi/blob/v0.2.1/scripts/install.ps1) before you run it.
-**Or by hand** (PowerShell or CMD — identical):
+**Or by hand** (PowerShell or CMD, identical):
 ```powershell
 python -m pip install --user pipx
@@ -120,10 +123,10 @@ colabapi doctor
 **`colabapi register`** makes it a real Windows program rather than a loose `.exe`:
-- it appears in **Settings → Installed apps** (and Add/Remove Programs), with a working uninstall entry;
-- **`colabapi`** runs from the **Start menu** and **Win+R**, without touching `PATH`.
+* it appears in **Settings, Installed apps** (and Add/Remove Programs) with the colabapi logo and a working uninstall entry;
+* a **Start menu** entry opens the colabapi window (`colabapi ui`), and typing **`colabapi`** works from **Win+R**, without touching `PATH`.
-It writes two keys under `HKEY_CURRENT_USER` (so no admin prompt), and `colabapi unregister` removes them cleanly.
+It writes per-user keys under `HKEY_CURRENT_USER` (so no admin prompt), and `colabapi unregister` removes them, the shortcut, and the icon cleanly.
 **Requires Python 3.12+** ([`winget install Python.Python.3.13`](https://learn.microsoft.com/en-us/windows/package-manager/winget/)). Works in Windows Terminal, PowerShell 5.1 and 7, and classic `cmd.exe`; ANSI colours are switched on automatically even on legacy consoles.
@@ -161,6 +164,8 @@ curl -fsSL https://raw.githubusercontent.com/lil-limbo/colabapi/main/scripts/ins
 ### From source
+No git? Download the ZIP from GitHub ("Code", then "Download ZIP"), unpack it, and run `pip install -e .` inside. With git:
 ```bash
 git clone https://github.com/lil-limbo/colabapi.git
 cd colabapi
@@ -207,13 +212,36 @@ colabapi service install
 systemctl --user start colabapi
 ```
+Prefer clicking? `colabapi ui` opens the same actions in a window.
 Press **Ctrl+C** to leave the monitor; type **`exit`** or press **Ctrl+D** to leave the shell. The Colab runtime keeps running until you stop it or Colab's timers end it.
+## The desktop window
+```bash
+colabapi ui
+```
+**Everything happens in the window. Nothing opens a second terminal.**
+* **Live graphs** across the top: CPU, RAM, GPU and VRAM, read from inside the selected runtime and plotted as they move.
+* **A real terminal** in the window — a full VT emulator, not a log box. `Shell` drops you into the selected runtime (auto-reconnecting, and your work keeps running in tmux across a drop). `New runtime`, `Sign in`, `Monitor` and the rest run *in that same terminal*, on a pty, so their prompts prompt and you answer them right there.
+* **Select a session, then act on it.** The list on the left is the selection `Shell`, `Stop` and `Monitor` operate on, and it is what the graphs follow. With nothing selected, those buttons are disabled rather than guessing.
+* **Stop** releases the runtime, with a confirmation first.
+* **Keyboard throughout:** Ctrl+N new runtime, Ctrl+S shell, Ctrl+K stop, Ctrl+M monitor, Ctrl+L sign in, F5 refresh. Enter on a session opens its shell. Every action is also a real, focusable button, and the menu bar carries the rest (REPL, status, runtimes, doctor, keep-alive service).
+Sign-in is Google's own browser flow, exactly as on the command line — colabapi never sees your password.
+* **Windows:** after `colabapi register`, "colabapi" in the Start menu and the app list opens this window directly. Windows has no pty, so there the interactive commands still open a console window; the shell, the graphs and everything else run in the window as normal.
+* **Linux:** the window uses Tkinter, which some distros package separately. If `colabapi ui` says Tkinter is missing, install it with `sudo apt install python3-tk` (Debian / Ubuntu / Kali) or `sudo dnf install python3-tkinter` (Fedora).
 ## Command reference
 | Command | What it does |
 |---|---|
+| `colabapi ui` | Open the colabapi window: live graphs, session list, and a built-in terminal that runs all of the below. |
 | `colabapi login` | Sign in via Google's browser flow (no password handled). |
+| `colabapi logout` | Sign out of Google and forget all sessions, for a clean start. |
 | `colabapi runtimes` | List runtime types and which need a paid plan. |
 | `colabapi run [--runtime KEY]` | Allocate a runtime and name the session (delegates to `colab new -s NAME`). |
 | `colabapi sessions` | List the sessions colabapi manages. |
@@ -230,9 +258,9 @@ Press **Ctrl+C** to leave the monitor; type **`exit`** or press **Ctrl+D** to le
 ## Running as a background service
-The service exists to fix a specific hole: Google's keepalive daemon is a child of *your terminal*. Close the laptop, log out of the VPS, or reboot, and it dies — so your runtime idles out even though nothing was actually wrong with it. Registering colabapi with the OS means the keepalive comes back on its own.
+The service exists to fix a specific hole: Google's keepalive daemon is a child of *your terminal*. Close the laptop, log out of the VPS, or reboot, and it dies, so your runtime idles out even though nothing was actually wrong with it. Registering colabapi with the OS means the keepalive comes back on its own.
-**Linux** — a systemd **user** service (no root required):
+**Linux**, a systemd **user** service (no root required):
 ```bash
 colabapi service install        # writes ~/.config/systemd/user/colabapi.service and enables lingering
@@ -242,7 +270,7 @@ systemctl --user status colabapi
 Lingering (`loginctl enable-linger`) is what lets the service keep running after you disconnect from the VPS, which is exactly what you want for an always-on demo.
-**Windows** — a **Scheduled Task** that runs at logon (no administrator rights, unlike a true Windows Service):
+**Windows**, a **Scheduled Task** that runs at logon (no administrator rights, unlike a true Windows Service):
 ```powershell
 colabapi service install
@@ -256,45 +284,24 @@ It appears in Task Scheduler as **colabapi**, and `colabapi service uninstall` r
 **We do not capture your login data. We do not collect anything.**
-- `colabapi` has **no code path that asks for, reads, stores, or transmits your Google password.** Sign in is delegated entirely to Google's official CLI and happens in your own browser under Google's real login flow.
-- `colabapi` operates **no servers**. There is nothing for your data to be sent to. The only network connections are between *your* machine, Google, and (via the official CLI) *your* Colab runtime.
-- The only things written to disk are **plain preferences and session bookkeeping** (which runtime you picked and when), under `~/.config/colabapi` and `~/.local/state/colabapi`.
-- The project is **MIT licensed and fully open source.** [Read the code](https://github.com/lil-limbo/colabapi/tree/main/colabapi). If you don't trust a claim here, verify it in the source. That's the point.
-<a name="staying-alive-what-actually-kills-a-colab-session"></a>
-## Staying alive: what actually kills a Colab session
-"Colab killed my session for no reason" is usually several different failures wearing the same coat. They have different causes and different fixes, and lumping them together is why they never get fixed. Here is the honest breakdown.
-**Two of them are our bugs to fix, and v0.2.0 fixes them:**
-| What goes wrong | Why | What colabapi does |
-|---|---|---|
-| **The connection silently dies** and the terminal just hangs | Google's client calls `run_forever()` with **no WebSocket keepalive ping**. A connection carrying no traffic gets quietly reaped by NAT tables, proxies and load balancers — neither end is told. The socket is now "half-open": you think you're connected, you're not. | We ping every 20s and expect a pong within 10s, so a dead connection is **detected in seconds instead of hanging forever**. |
-| **One blip ends the session for good** | Google's client has **no reconnect logic at all**. Wi-Fi handover, VPN reconnect, closing your laptop lid — the socket closes, you get `Connection closed.`, and that's it. | We **reconnect automatically** with exponential backoff and jitter, re-reading your token each attempt. |
-| **Your running job dies with the connection** | If a training run is in the foreground of the remote shell, losing the shell can take the job with it. | Your shell runs inside a **tmux session on the VM that we name and own**, so the job keeps running and reconnecting **puts you back in front of it**. |
-| **The keepalive quietly stops** | Google's keepalive daemon is a child of *your terminal*, and it deliberately exits after 24h. Laptop sleeps → daemon dies → runtime idles out. | We **supervise it and restart it**, and `colabapi service install` keeps that running across logout and reboot. |
-**And these are hard caps that nobody can bypass — colabapi doesn't pretend to:**
-- **Absolute max lifetime (~12 h free, up to 24 h paid).** Enforced server-side. We show an *estimate* of time left and stop cleanly when it's reached, rather than hammering a dead endpoint.
-- **GPU quota / "cannot currently connect to a GPU backend".** Google deliberately doesn't publish the numbers, and they vary. Waiting or upgrading are the only levers.
-- **Out-of-memory or a full disk inside the VM.** That's a workload problem, not a connectivity problem, and we report it as one instead of calling it a disconnect.
-The distinction that matters: **your connection dying is not your runtime dying.** Most "session died" reports are the former, which is recoverable — so colabapi recovers from it, and only tells you the session has genuinely ended when Colab actually says so (a 401/404 from the runtime), instead of guessing.
+* `colabapi` has **no code path that asks for, reads, stores, or transmits your Google password.** Sign in is delegated entirely to Google's official CLI and happens in your own browser under Google's real login flow.
+* `colabapi` operates **no servers**. There is nothing for your data to be sent to. The only network connections are between *your* machine, Google, and (via the official CLI) *your* Colab runtime.
+* The only things written to disk are **plain preferences and session bookkeeping** (which runtime you picked and when), under `~/.config/colabapi` and `~/.local/state/colabapi`.
+* Signing out is one command: `colabapi logout` removes the Google token that Google's CLI cached and forgets every session.
+* The project is **MIT licensed and fully open source.** [Read the code](https://github.com/lil-limbo/colabapi/tree/main/colabapi). If you don't trust a claim here, verify it in the source. That's the point.
 ## Safety (please read)
-`colabapi` deliberately uses **Google's official CLI** instead of the older "SSH into Colab via ngrok/cloudflared" trick, because Colab's own FAQ lists *remote control such as SSH shells* as an activity that can get a runtime — or an account — terminated. Using the sanctioned path is far safer for your Google account.
+`colabapi` deliberately uses **Google's official CLI** instead of the older "SSH into Colab via ngrok/cloudflared" trick, because Colab's own FAQ lists *remote control such as SSH shells* as an activity that can get a runtime or an account terminated. Using the sanctioned path is far safer for your Google account.
-**The keepalive is Google's own.** colabapi doesn't invent a scheme to defeat the idle timeout: it runs the keepalive daemon that ships inside Google's CLI, which pings Colab's own tunnel endpoint once a minute. Our reconnect pings are ordinary WebSocket keepalives on our own socket — standard practice for any long-lived connection, and *not* synthetic activity designed to look like a user who isn't there.
+**The keepalive is Google's own.** colabapi doesn't invent a scheme to defeat the idle timeout: it runs the keepalive daemon that ships inside Google's CLI, which pings Colab's own tunnel endpoint once a minute. Our reconnect pings are ordinary WebSocket keepalives on our own socket, standard practice for any long-lived connection, and *not* synthetic activity designed to look like a user who isn't there.
 Be a good citizen: **don't hold GPU runtimes idle just to reserve them.** Colab's abuse heuristics are real and they do flag paying users. Nothing in colabapi tries to hide what you're doing, and you shouldn't either.
 ## FAQ
 **Does colabapi see or store my Google password?**
-No. Sign in is handled by Google's official CLI in your browser. `colabapi` has no password code path at all.
+No. Sign in is handled by Google's official CLI in your browser. `colabapi` has no password code path at all. `colabapi logout` signs you out again whenever you want.
 **How do I keep a Google Colab session alive after closing the browser?**
 Allocate a runtime with `colabapi run`, then install the service (`colabapi service install`). Google's keepalive holds off the idle timeout; the systemd service keeps `colabapi` supervising it after you log out.
@@ -302,17 +309,20 @@ Allocate a runtime with `colabapi run`, then install the service (`colabapi serv
 **Can I get a terminal / shell into Google Colab?**
 Yes. `colabapi shell` opens a live PTY on the runtime via Google's `colab console`. `colabapi repl` gives a Python REPL.
+**Is there a graphical interface?**
+Yes. `colabapi ui` opens a desktop window with buttons for every common action, on Linux and Windows. On Windows, `colabapi register` also puts it in the Start menu and the app list, so you can open it like any other program.
 **Can I use a free Colab account?**
 Yes. CPU and T4 GPU runtimes are available on the free tier. Paid runtimes (L4, A100, H100, TPU) are shown but flagged; Colab itself refuses them on free accounts.
 **How is this different from Google's official `colab` CLI?**
-`colabapi` *uses* the official CLI under the hood, and adds the things it doesn't do: **it runs on Windows** (the official one cannot), **it reconnects when the network drops** (the official one has no keepalive and no retry), and it keeps the keepalive daemon alive across logout and reboot. On top of that: one `colabapi` command, a runtime picker with paid-tier flags, a live resource monitor, a session timer, and a ready-made background service. If you only need raw commands on Linux, use `colab` directly.
+`colabapi` *uses* the official CLI under the hood, and adds the things it doesn't do: **it runs on Windows** (the official one cannot), **it reconnects when the network drops** (the official one has no keepalive and no retry), and it keeps the keepalive daemon alive across logout and reboot. On top of that: one `colabapi` command, a desktop window, a runtime picker with paid tier flags, a live resource monitor, a session timer, and a ready-made background service. If you only need raw commands on Linux, use `colab` directly.
 **Does colabapi work on Windows? Google says its CLI doesn't.**
-Yes — that's one of the two reasons this project exists. Google's CLI imports `termios`, a POSIX-only module, at startup, so on Windows it dies before running any command at all. colabapi supplies the missing pieces through the Win32 console API, so Google's CLI runs unmodified in PowerShell and CMD. We don't patch their code, so their updates keep working. See [Windows](#windows).
+Yes, that's one of the two reasons this project exists. Google's CLI imports `termios`, a POSIX-only module, at startup, so on Windows it dies before running any command at all. colabapi supplies the missing pieces through the Win32 console API, so Google's CLI runs unmodified in PowerShell and CMD. We don't patch their code, so their updates keep working. See [Windows](#windows).
 **My session keeps dying. Is that Colab or colabapi?**
-Usually neither — it's the *connection*, not the runtime, and it's the thing v0.2.0 was built to fix. See [Staying alive](#staying-alive-what-actually-kills-a-colab-session) for what each failure actually is and which ones are hard caps nobody can bypass.
+Usually neither: it's the *connection*, not the runtime. colabapi's reconnect and keepalive supervision exist exactly for that, and the hard limits that remain (Colab's idle timeout and max lifetime cap) are enforced server-side and shown by `colabapi status`.
 **What happens to my running job if my Wi-Fi drops?**
 It keeps running. Your shell lives inside a tmux session on the Colab VM, so the job is not attached to your connection; colabapi reconnects and puts you back in front of it. You can also detach on purpose with **Ctrl+]**.
@@ -325,7 +335,7 @@ No. `colabapi` is an independent, open source wrapper. "Google Colab" is a trade
 ## Contributing
-Issues and pull requests welcome. If Google changes the official CLI's flags, the runtime→flag mapping lives in a single file (`colabapi/runtime.py`) and `colabapi doctor` will flag drift.
+Issues and pull requests welcome. If Google changes the official CLI's flags, the mapping from runtime to flag lives in a single file (`colabapi/runtime.py`) and `colabapi doctor` will flag drift.
 ## License

{colabapi-0.2.0 → colabapi-0.2.2}/README.md RENAMED Viewed

@@ -1,15 +1,15 @@
 # colabapi: a terminal for a persistent Google Colab runtime
-**Run Google Colab from your own terminal — on Linux, macOS, *and Windows* — keep the runtime alive after you close the browser, and reach its shell from any VPS or laptop.** `colabapi` is a small, open source command line tool that turns a Google Colab GPU/TPU session into something you can drive headlessly. Perfect for demos, MVPs, and long running jobs that must survive after the Colab web tab is gone.
+**Run Google Colab from your own terminal on Linux, macOS, *and Windows*. Keep the runtime alive after you close the browser, and reach its shell from any VPS or laptop.** `colabapi` is a small, open source command line tool (with an optional desktop window) that turns a Google Colab GPU/TPU session into something you can drive headlessly. Perfect for demos, MVPs, and long running jobs that must survive after the Colab web tab is gone.
 > **In one line:** `colabapi` gives you a persistent Colab terminal on your own machine, using Google's official, ban safe sign in and tunnel, and it never sees your Google password.
 **Two things you only get here:**
-- 🪟 **It works on Windows.** Google's official Colab CLI is [Linux and macOS only](#windows) — it fails on Windows before it can even parse a command. colabapi ships the compatibility layer that makes it run in PowerShell and CMD.
-- 🔌 **It survives a dropped connection.** Google's terminal sets no WebSocket keepalive and has no reconnect, so one blip ends your session. colabapi pings, reconnects with backoff, and keeps your running job alive on the VM. [How](#staying-alive-what-actually-kills-a-colab-session).
+* 🪟 **It works on Windows.** Google's official Colab CLI is [Linux and macOS only](#windows). It fails on Windows before it can even parse a command. colabapi ships the compatibility layer that makes it run in PowerShell and CMD, and it registers as a real Windows app with its own icon and Start menu entry.
+* 🔌 **It survives a dropped connection.** Google's terminal sets no WebSocket keepalive and has no reconnect, so one blip ends your session. colabapi pings, reconnects with backoff, and keeps your running job alive on the VM.
-<!-- Keywords: google colab terminal, colab cli, colab ssh, colab windows, colab powershell, persistent colab, keep colab alive, headless colab, run colab from terminal, colab gpu terminal, colab from vps, colab session keep alive -->
+<!-- Keywords: google colab terminal, colab cli, colab ssh, colab windows, colab powershell, persistent colab, keep colab alive, headless colab, run colab from terminal, colab gpu terminal, colab from vps, colab session keep alive, colab gui -->
 ---
@@ -17,37 +17,38 @@
 Google Colab is fantastic free (and paid) GPU/TPU compute, but it only lives inside a browser tab. Close the tab or lose your connection and the session can go with it. That makes it awkward to:
-- **demo an MVP** that needs a GPU without renting a server,
-- **reach the runtime from a VPS** or a headless box,
-- **register it as a background service** that stays up, or
-- **watch CPU / GPU / RAM** from a normal terminal.
+* **demo an MVP** that needs a GPU without renting a server,
+* **reach the runtime from a VPS** or a headless box,
+* **register it as a background service** that stays up, or
+* **watch CPU / GPU / RAM** from a normal terminal.
-`colabapi` solves this by wrapping **Google's official [`google-colab-cli`](https://github.com/googlecolab/google-colab-cli)** with a friendly single command, a systemd service, a runtime picker, a live resource monitor, and a session time display. You sign in through Google's own browser flow; `colabapi` connects over Google's sanctioned tunnel.
+`colabapi` solves this by wrapping **Google's official [`google-colab-cli`](https://github.com/googlecolab/google-colab-cli)** with a friendly single command, a graphical window, a systemd service, a runtime picker, a live resource monitor, and a session time display. You sign in through Google's own browser flow; `colabapi` connects over Google's sanctioned tunnel.
 ## Features
-- 🪟 **Works on Windows** (PowerShell + CMD), which Google's own CLI does not. Registers as real installed software.
-- 🔌 **Reconnects instead of dying.** WebSocket keepalive pings, exponential backoff, and your work keeps running on the VM across the drop.
-- 🔐 **Browser sign in, no password handling.** Authentication happens in Google's own login flow (including 2FA / device checks). `colabapi` never asks for, stores, or transmits your Google credentials.
-- 💻 **Real terminal into the runtime.** `colabapi shell` drops you into a live shell on the Colab VM. `colabapi repl` gives you a Python REPL.
-- 🎛 **Runtime picker.** List CPU / T4 / L4 / G4 / A100 / H100 / TPU options; paid tier runtimes are clearly flagged as unavailable on a free account.
-- 📈 **Live CPU / GPU / RAM monitor.** `colabapi monitor` streams runtime stats to your terminal (psutil + `nvidia-smi`).
-- ⏱ **Session time display.** See uptime and an estimate of how long before Colab's max lifetime cap.
-- ♻️ **Keepalive that stays up.** Runs Google's own keepalive daemon — and restarts it when it dies, which it otherwise does silently.
-- 🧩 **Runs as a background service.** systemd on Linux, a Scheduled Task on Windows, so your session survives logout and reboot.
-- 🔎 **Inspectable & MIT licensed.** Read every line. Nothing phones home.
+* 🖥 **A desktop app, not just a CLI.** `colabapi ui` opens a clean graphical window (white, minimal, works on Linux and Windows) with live CPU / RAM / GPU / VRAM graphs, a session list, and a **real terminal built into the window** — the shell, sign-in, runtime allocation and everything else run *inside it*, not in a terminal it throws you out to. On Windows it opens straight from the Start menu and the app list.
+* 🪟 **Works on Windows** (PowerShell + CMD), which Google's own CLI does not. Registers as real installed software with its own logo.
+* 🔌 **Reconnects instead of dying.** WebSocket keepalive pings, exponential backoff, and your work keeps running on the VM across the drop.
+* 🔐 **Browser sign in, no password handling.** Authentication happens in Google's own login flow (including 2FA / device checks). `colabapi` never asks for, stores, or transmits your Google credentials. `colabapi logout` signs you out again in one command.
+* 💻 **Real terminal into the runtime.** `colabapi shell` drops you into a live shell on the Colab VM. `colabapi repl` gives you a Python REPL.
+* 🎛 **Runtime picker.** List CPU / T4 / L4 / G4 / A100 / H100 / TPU options; paid tier runtimes are clearly flagged as unavailable on a free account.
+* 📈 **Live CPU / GPU / RAM monitor.** `colabapi monitor` streams runtime stats to your terminal (psutil + `nvidia-smi`).
+* ⏱ **Session time display.** See uptime and an estimate of how long before Colab's max lifetime cap.
+* ♻️ **Keepalive that stays up.** Runs Google's own keepalive daemon and restarts it when it dies, which it otherwise does silently.
+* 🧩 **Runs as a background service.** systemd on Linux, a Scheduled Task on Windows, so your session survives logout and reboot.
+* 🔎 **Inspectable & MIT licensed.** Read every line. Nothing phones home.
 ## How it works
 ```
 you  >  colabapi (this tool)  >  colab_cli (Google's official CLI)  >  Google's tunnel  >  your Colab runtime (GPU/TPU VM)
-colabapi adds: Windows support, auto-reconnect, keepalive supervision,
-               runtime picker, monitor, session timer, background service
+colabapi adds: Windows support, auto-reconnect, keepalive supervision, a desktop
+               window, runtime picker, monitor, session timer, background service
 colabapi never handles your Google password
 ```
-`colabapi` is an **orchestration and reliability layer**. The heavy lifting — OAuth sign in, allocating the runtime, and the encrypted tunnel — is delegated to Google's first party CLI, which is the safe, supported way to do this. We do not reimplement any of it; we make it run where it otherwise cannot, and keep it running when it otherwise would not.
+`colabapi` is an **orchestration and reliability layer**. The heavy lifting (OAuth sign in, allocating the runtime, and the encrypted tunnel) is delegated to Google's first party CLI, which is the safe, supported way to do this. We do not reimplement any of it; we make it run where it otherwise cannot, and keep it running when it otherwise would not.
 ## Install
@@ -62,17 +63,17 @@ pipx install colabapi
 <a name="windows"></a>
 ### Windows (PowerShell or CMD)
-> **Google's official Colab CLI does not support Windows at all** — the docs say Linux and macOS only, and on Windows it raises `ImportError: No module named 'termios'` before it can parse a single command. **colabapi fixes that.** It ships a compatibility layer that supplies the POSIX pieces Windows lacks, so Google's CLI runs here unmodified — we patch nothing inside it, so their updates keep working.
+> **Google's official Colab CLI does not support Windows at all.** The docs say Linux and macOS only, and on Windows it raises `ImportError: No module named 'termios'` before it can parse a single command. **colabapi fixes that.** It ships a compatibility layer that supplies the POSIX pieces Windows lacks, so Google's CLI runs here unmodified. We patch nothing inside it, so their updates keep working.
 **One line, in PowerShell:**
 ```powershell
-irm https://raw.githubusercontent.com/lil-limbo/colabapi/main/scripts/install.ps1 | iex
+irm https://raw.githubusercontent.com/lil-limbo/colabapi/v0.2.1/scripts/install.ps1 | iex
 ```
-That installs Python's `pipx` if needed, installs colabapi, fixes your `PATH`, and registers it with Windows. No administrator rights required.
+That finds Python 3.12+ (and offers to install it with winget if you have none), installs Python's `pipx` if needed, installs colabapi, fixes your `PATH`, and registers it with Windows. No administrator rights required. The URL is pinned to the released tag, so you can [read exactly what will run](https://github.com/lil-limbo/colabapi/blob/v0.2.1/scripts/install.ps1) before you run it.
-**Or by hand** (PowerShell or CMD — identical):
+**Or by hand** (PowerShell or CMD, identical):
 ```powershell
 python -m pip install --user pipx
@@ -89,10 +90,10 @@ colabapi doctor
 **`colabapi register`** makes it a real Windows program rather than a loose `.exe`:
-- it appears in **Settings → Installed apps** (and Add/Remove Programs), with a working uninstall entry;
-- **`colabapi`** runs from the **Start menu** and **Win+R**, without touching `PATH`.
+* it appears in **Settings, Installed apps** (and Add/Remove Programs) with the colabapi logo and a working uninstall entry;
+* a **Start menu** entry opens the colabapi window (`colabapi ui`), and typing **`colabapi`** works from **Win+R**, without touching `PATH`.
-It writes two keys under `HKEY_CURRENT_USER` (so no admin prompt), and `colabapi unregister` removes them cleanly.
+It writes per-user keys under `HKEY_CURRENT_USER` (so no admin prompt), and `colabapi unregister` removes them, the shortcut, and the icon cleanly.
 **Requires Python 3.12+** ([`winget install Python.Python.3.13`](https://learn.microsoft.com/en-us/windows/package-manager/winget/)). Works in Windows Terminal, PowerShell 5.1 and 7, and classic `cmd.exe`; ANSI colours are switched on automatically even on legacy consoles.
@@ -130,6 +131,8 @@ curl -fsSL https://raw.githubusercontent.com/lil-limbo/colabapi/main/scripts/ins
 ### From source
+No git? Download the ZIP from GitHub ("Code", then "Download ZIP"), unpack it, and run `pip install -e .` inside. With git:
 ```bash
 git clone https://github.com/lil-limbo/colabapi.git
 cd colabapi
@@ -176,13 +179,36 @@ colabapi service install
 systemctl --user start colabapi
 ```
+Prefer clicking? `colabapi ui` opens the same actions in a window.
 Press **Ctrl+C** to leave the monitor; type **`exit`** or press **Ctrl+D** to leave the shell. The Colab runtime keeps running until you stop it or Colab's timers end it.
+## The desktop window
+```bash
+colabapi ui
+```
+**Everything happens in the window. Nothing opens a second terminal.**
+* **Live graphs** across the top: CPU, RAM, GPU and VRAM, read from inside the selected runtime and plotted as they move.
+* **A real terminal** in the window — a full VT emulator, not a log box. `Shell` drops you into the selected runtime (auto-reconnecting, and your work keeps running in tmux across a drop). `New runtime`, `Sign in`, `Monitor` and the rest run *in that same terminal*, on a pty, so their prompts prompt and you answer them right there.
+* **Select a session, then act on it.** The list on the left is the selection `Shell`, `Stop` and `Monitor` operate on, and it is what the graphs follow. With nothing selected, those buttons are disabled rather than guessing.
+* **Stop** releases the runtime, with a confirmation first.
+* **Keyboard throughout:** Ctrl+N new runtime, Ctrl+S shell, Ctrl+K stop, Ctrl+M monitor, Ctrl+L sign in, F5 refresh. Enter on a session opens its shell. Every action is also a real, focusable button, and the menu bar carries the rest (REPL, status, runtimes, doctor, keep-alive service).
+Sign-in is Google's own browser flow, exactly as on the command line — colabapi never sees your password.
+* **Windows:** after `colabapi register`, "colabapi" in the Start menu and the app list opens this window directly. Windows has no pty, so there the interactive commands still open a console window; the shell, the graphs and everything else run in the window as normal.
+* **Linux:** the window uses Tkinter, which some distros package separately. If `colabapi ui` says Tkinter is missing, install it with `sudo apt install python3-tk` (Debian / Ubuntu / Kali) or `sudo dnf install python3-tkinter` (Fedora).
 ## Command reference
 | Command | What it does |
 |---|---|
+| `colabapi ui` | Open the colabapi window: live graphs, session list, and a built-in terminal that runs all of the below. |
 | `colabapi login` | Sign in via Google's browser flow (no password handled). |
+| `colabapi logout` | Sign out of Google and forget all sessions, for a clean start. |
 | `colabapi runtimes` | List runtime types and which need a paid plan. |
 | `colabapi run [--runtime KEY]` | Allocate a runtime and name the session (delegates to `colab new -s NAME`). |
 | `colabapi sessions` | List the sessions colabapi manages. |
@@ -199,9 +225,9 @@ Press **Ctrl+C** to leave the monitor; type **`exit`** or press **Ctrl+D** to le
 ## Running as a background service
-The service exists to fix a specific hole: Google's keepalive daemon is a child of *your terminal*. Close the laptop, log out of the VPS, or reboot, and it dies — so your runtime idles out even though nothing was actually wrong with it. Registering colabapi with the OS means the keepalive comes back on its own.
+The service exists to fix a specific hole: Google's keepalive daemon is a child of *your terminal*. Close the laptop, log out of the VPS, or reboot, and it dies, so your runtime idles out even though nothing was actually wrong with it. Registering colabapi with the OS means the keepalive comes back on its own.
-**Linux** — a systemd **user** service (no root required):
+**Linux**, a systemd **user** service (no root required):
 ```bash
 colabapi service install        # writes ~/.config/systemd/user/colabapi.service and enables lingering
@@ -211,7 +237,7 @@ systemctl --user status colabapi
 Lingering (`loginctl enable-linger`) is what lets the service keep running after you disconnect from the VPS, which is exactly what you want for an always-on demo.
-**Windows** — a **Scheduled Task** that runs at logon (no administrator rights, unlike a true Windows Service):
+**Windows**, a **Scheduled Task** that runs at logon (no administrator rights, unlike a true Windows Service):
 ```powershell
 colabapi service install
@@ -225,45 +251,24 @@ It appears in Task Scheduler as **colabapi**, and `colabapi service uninstall` r
 **We do not capture your login data. We do not collect anything.**
-- `colabapi` has **no code path that asks for, reads, stores, or transmits your Google password.** Sign in is delegated entirely to Google's official CLI and happens in your own browser under Google's real login flow.
-- `colabapi` operates **no servers**. There is nothing for your data to be sent to. The only network connections are between *your* machine, Google, and (via the official CLI) *your* Colab runtime.
-- The only things written to disk are **plain preferences and session bookkeeping** (which runtime you picked and when), under `~/.config/colabapi` and `~/.local/state/colabapi`.
-- The project is **MIT licensed and fully open source.** [Read the code](https://github.com/lil-limbo/colabapi/tree/main/colabapi). If you don't trust a claim here, verify it in the source. That's the point.
-<a name="staying-alive-what-actually-kills-a-colab-session"></a>
-## Staying alive: what actually kills a Colab session
-"Colab killed my session for no reason" is usually several different failures wearing the same coat. They have different causes and different fixes, and lumping them together is why they never get fixed. Here is the honest breakdown.
-**Two of them are our bugs to fix, and v0.2.0 fixes them:**
-| What goes wrong | Why | What colabapi does |
-|---|---|---|
-| **The connection silently dies** and the terminal just hangs | Google's client calls `run_forever()` with **no WebSocket keepalive ping**. A connection carrying no traffic gets quietly reaped by NAT tables, proxies and load balancers — neither end is told. The socket is now "half-open": you think you're connected, you're not. | We ping every 20s and expect a pong within 10s, so a dead connection is **detected in seconds instead of hanging forever**. |
-| **One blip ends the session for good** | Google's client has **no reconnect logic at all**. Wi-Fi handover, VPN reconnect, closing your laptop lid — the socket closes, you get `Connection closed.`, and that's it. | We **reconnect automatically** with exponential backoff and jitter, re-reading your token each attempt. |
-| **Your running job dies with the connection** | If a training run is in the foreground of the remote shell, losing the shell can take the job with it. | Your shell runs inside a **tmux session on the VM that we name and own**, so the job keeps running and reconnecting **puts you back in front of it**. |
-| **The keepalive quietly stops** | Google's keepalive daemon is a child of *your terminal*, and it deliberately exits after 24h. Laptop sleeps → daemon dies → runtime idles out. | We **supervise it and restart it**, and `colabapi service install` keeps that running across logout and reboot. |
-**And these are hard caps that nobody can bypass — colabapi doesn't pretend to:**
-- **Absolute max lifetime (~12 h free, up to 24 h paid).** Enforced server-side. We show an *estimate* of time left and stop cleanly when it's reached, rather than hammering a dead endpoint.
-- **GPU quota / "cannot currently connect to a GPU backend".** Google deliberately doesn't publish the numbers, and they vary. Waiting or upgrading are the only levers.
-- **Out-of-memory or a full disk inside the VM.** That's a workload problem, not a connectivity problem, and we report it as one instead of calling it a disconnect.
-The distinction that matters: **your connection dying is not your runtime dying.** Most "session died" reports are the former, which is recoverable — so colabapi recovers from it, and only tells you the session has genuinely ended when Colab actually says so (a 401/404 from the runtime), instead of guessing.
+* `colabapi` has **no code path that asks for, reads, stores, or transmits your Google password.** Sign in is delegated entirely to Google's official CLI and happens in your own browser under Google's real login flow.
+* `colabapi` operates **no servers**. There is nothing for your data to be sent to. The only network connections are between *your* machine, Google, and (via the official CLI) *your* Colab runtime.
+* The only things written to disk are **plain preferences and session bookkeeping** (which runtime you picked and when), under `~/.config/colabapi` and `~/.local/state/colabapi`.
+* Signing out is one command: `colabapi logout` removes the Google token that Google's CLI cached and forgets every session.
+* The project is **MIT licensed and fully open source.** [Read the code](https://github.com/lil-limbo/colabapi/tree/main/colabapi). If you don't trust a claim here, verify it in the source. That's the point.
 ## Safety (please read)
-`colabapi` deliberately uses **Google's official CLI** instead of the older "SSH into Colab via ngrok/cloudflared" trick, because Colab's own FAQ lists *remote control such as SSH shells* as an activity that can get a runtime — or an account — terminated. Using the sanctioned path is far safer for your Google account.
+`colabapi` deliberately uses **Google's official CLI** instead of the older "SSH into Colab via ngrok/cloudflared" trick, because Colab's own FAQ lists *remote control such as SSH shells* as an activity that can get a runtime or an account terminated. Using the sanctioned path is far safer for your Google account.
-**The keepalive is Google's own.** colabapi doesn't invent a scheme to defeat the idle timeout: it runs the keepalive daemon that ships inside Google's CLI, which pings Colab's own tunnel endpoint once a minute. Our reconnect pings are ordinary WebSocket keepalives on our own socket — standard practice for any long-lived connection, and *not* synthetic activity designed to look like a user who isn't there.
+**The keepalive is Google's own.** colabapi doesn't invent a scheme to defeat the idle timeout: it runs the keepalive daemon that ships inside Google's CLI, which pings Colab's own tunnel endpoint once a minute. Our reconnect pings are ordinary WebSocket keepalives on our own socket, standard practice for any long-lived connection, and *not* synthetic activity designed to look like a user who isn't there.
 Be a good citizen: **don't hold GPU runtimes idle just to reserve them.** Colab's abuse heuristics are real and they do flag paying users. Nothing in colabapi tries to hide what you're doing, and you shouldn't either.
 ## FAQ
 **Does colabapi see or store my Google password?**
-No. Sign in is handled by Google's official CLI in your browser. `colabapi` has no password code path at all.
+No. Sign in is handled by Google's official CLI in your browser. `colabapi` has no password code path at all. `colabapi logout` signs you out again whenever you want.
 **How do I keep a Google Colab session alive after closing the browser?**
 Allocate a runtime with `colabapi run`, then install the service (`colabapi service install`). Google's keepalive holds off the idle timeout; the systemd service keeps `colabapi` supervising it after you log out.
@@ -271,17 +276,20 @@ Allocate a runtime with `colabapi run`, then install the service (`colabapi serv
 **Can I get a terminal / shell into Google Colab?**
 Yes. `colabapi shell` opens a live PTY on the runtime via Google's `colab console`. `colabapi repl` gives a Python REPL.
+**Is there a graphical interface?**
+Yes. `colabapi ui` opens a desktop window with buttons for every common action, on Linux and Windows. On Windows, `colabapi register` also puts it in the Start menu and the app list, so you can open it like any other program.
 **Can I use a free Colab account?**
 Yes. CPU and T4 GPU runtimes are available on the free tier. Paid runtimes (L4, A100, H100, TPU) are shown but flagged; Colab itself refuses them on free accounts.
 **How is this different from Google's official `colab` CLI?**
-`colabapi` *uses* the official CLI under the hood, and adds the things it doesn't do: **it runs on Windows** (the official one cannot), **it reconnects when the network drops** (the official one has no keepalive and no retry), and it keeps the keepalive daemon alive across logout and reboot. On top of that: one `colabapi` command, a runtime picker with paid-tier flags, a live resource monitor, a session timer, and a ready-made background service. If you only need raw commands on Linux, use `colab` directly.
+`colabapi` *uses* the official CLI under the hood, and adds the things it doesn't do: **it runs on Windows** (the official one cannot), **it reconnects when the network drops** (the official one has no keepalive and no retry), and it keeps the keepalive daemon alive across logout and reboot. On top of that: one `colabapi` command, a desktop window, a runtime picker with paid tier flags, a live resource monitor, a session timer, and a ready-made background service. If you only need raw commands on Linux, use `colab` directly.
 **Does colabapi work on Windows? Google says its CLI doesn't.**
-Yes — that's one of the two reasons this project exists. Google's CLI imports `termios`, a POSIX-only module, at startup, so on Windows it dies before running any command at all. colabapi supplies the missing pieces through the Win32 console API, so Google's CLI runs unmodified in PowerShell and CMD. We don't patch their code, so their updates keep working. See [Windows](#windows).
+Yes, that's one of the two reasons this project exists. Google's CLI imports `termios`, a POSIX-only module, at startup, so on Windows it dies before running any command at all. colabapi supplies the missing pieces through the Win32 console API, so Google's CLI runs unmodified in PowerShell and CMD. We don't patch their code, so their updates keep working. See [Windows](#windows).
 **My session keeps dying. Is that Colab or colabapi?**
-Usually neither — it's the *connection*, not the runtime, and it's the thing v0.2.0 was built to fix. See [Staying alive](#staying-alive-what-actually-kills-a-colab-session) for what each failure actually is and which ones are hard caps nobody can bypass.
+Usually neither: it's the *connection*, not the runtime. colabapi's reconnect and keepalive supervision exist exactly for that, and the hard limits that remain (Colab's idle timeout and max lifetime cap) are enforced server-side and shown by `colabapi status`.
 **What happens to my running job if my Wi-Fi drops?**
 It keeps running. Your shell lives inside a tmux session on the Colab VM, so the job is not attached to your connection; colabapi reconnects and puts you back in front of it. You can also detach on purpose with **Ctrl+]**.
@@ -294,7 +302,7 @@ No. `colabapi` is an independent, open source wrapper. "Google Colab" is a trade
 ## Contributing
-Issues and pull requests welcome. If Google changes the official CLI's flags, the runtime→flag mapping lives in a single file (`colabapi/runtime.py`) and `colabapi doctor` will flag drift.
+Issues and pull requests welcome. If Google changes the official CLI's flags, the mapping from runtime to flag lives in a single file (`colabapi/runtime.py`) and `colabapi doctor` will flag drift.
 ## License

{colabapi-0.2.0 → colabapi-0.2.2}/colabapi/__init__.py RENAMED Viewed

@@ -4,4 +4,4 @@ The tool never handles your Google password. You sign in to Colab in your own
 browser; colabapi connects to the running runtime over a secure tunnel.
 """
-__version__ = "0.2.0"
+__version__ = "0.2.2"

colabapi 0.2.0__tar.gz → 0.2.2__tar.gz

colabapi 0.2.0tar.gz → 0.2.2tar.gz