Metadata-Version: 2.4
Name: kache-ssh
Version: 1.1.0
Classifier: Development Status :: 4 - Beta
Classifier: Environment :: Console
Classifier: Environment :: Win32 (MS Windows)
Classifier: Intended Audience :: Developers
Classifier: Intended Audience :: System Administrators
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: Microsoft :: Windows :: Windows 10
Classifier: Operating System :: Microsoft :: Windows :: Windows 11
Classifier: Programming Language :: Rust
Classifier: Topic :: System :: Networking
Classifier: Topic :: System :: Systems Administration
License-File: LICENSE
Summary: One terminal for all your computers: commands, jobs, files and chat across your devices, for people and AI agents.
Keywords: ssh,remote,devices,terminal,jobs,agents,mcp,tailscale
Author: Simon Malm
License: MIT
Requires-Python: >=3.8
Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
Project-URL: Homepage, https://pypi.org/project/kache-ssh/

# Kache

One terminal for all your computers. Run commands and long jobs on your
other devices, move files between them, see how they are doing, and see
who (or which AI agent) is working where, from a window, the command line,
or an AI agent's tools.

## Install

```console
pip install kache-ssh
kache
```

`kache` opens the Kache window. From then on Kache starts when you log in;
a small dot in the taskbar's hidden icons shows it is running (double-click
opens the window, right-click shows this device's address and Exit).

Kache is two small programs (about 25 MB together, written in Rust) and
uses little memory and almost no CPU while idle. Windows 10/11 is supported
today; the command line also builds on Linux and macOS.

## Pair your devices

On the device you want to command from:

```console
kache pair 192.168.1.30          (or its Tailscale name or IP)
```

Both devices show the same six-digit code; accept on the other device (the
window asks, or `kache accept`). Each device has its own key; no passwords
are sent and nothing goes through anyone else's server. Devices paired at
home keep working over Tailscale when you are away.

## Use it

```console
kache run desktop -- nvidia-smi                      a command, output live
kache run desktop --shell bash -- ls -la             in a chosen shell
kache job start desktop -m "train style-v1" -- python train.py
kache jobs                                           jobs everywhere, with owners
kache job log J-3f2a9c -f                            follow a job
kache push notes.txt desktop:Desktop                 copy files there
kache pull desktop:C:/runs/x/latest.pt .             and back
kache copy desktop:C:/runs/x/latest.pt all:Downloads to every other device
kache sync ./project desktop:C:/project --watch      keep a folder in sync
kache devices                                        who is online, CPU/RAM/GPU
kache actors                                         who is working where
kache chat @claude-code is the run done?             talk to people and agents
```

Commands run exactly as written, in the shell you choose (PowerShell, Bash,
cmd or Zsh); each session keeps its folder and variables, like a terminal.
Cancelling a command (Ctrl+C) stops everything it started, and nothing else.

In the window: type in the terminal and press Enter; **Tab** switches shell,
**Shift+Tab** switches device, **Ctrl+C** stops the command. Everything done
through Kache, on every device, scrolls by on the right, chat included, with
who is working right now beside its title; **Ctrl+F** searches it. The chat
is one room: everyone sees every message, and `@name` also pings them.

## Working together

Every command, job and change is shown with who did it ("claude-code on
laptop"). When someone starts work on a device where others are working,
Kache tells them who is busy with what and asks once; it asks again only
when someone starts new work there. Work can say what it uses
(`--uses gpu`) so unrelated work does not count as a conflict.

Jobs need a short description, like a commit message, so everyone can see
what each job is for. Messages (`kache chat`, or the Chat tab) reach every
device; mentioning someone (`@simon`) pings them. Messages never block
work, unless sent as `--urgent`.

## More

- Files without a shell: `kache cat`, `ls`, `find`, `tail`; `kache patch`
  and `write` refuse if the file changed since you read it, and every change
  can be undone (`kache undo`).
- Services that Kache keeps running, and schedules (`kache service`,
  `kache schedule`).
- `kache wait` for a file, a log line, a job or a port; `kache wake` for
  wake-on-LAN; `kache screenshot desktop`; `kache stats` for 7 days of
  health history; `kache ssh` shows plain SSH logins.
- `kache startup on --at-boot` starts Kache before anyone logs in (needs
  administrator rights once).
- `kache update` updates every device, the others first.
- AI agents: `kache mcp` serves Kache as tools (Model Context Protocol);
  `kache guide` explains the JSON output and exit codes.

## Upgrading from Kache 0.x

Kache 1.0 keeps your device's identity and pairings (same state folder,
same files). After `pip install -U kache-ssh`, run `kache startup on` (add
`--at-boot` if you used it) to replace the old startup entries.

## License

MIT

