Metadata-Version: 2.5
Name: akctl
Version: 0.1.7
Summary: A simple CLI toolkit for everyday server management tasks
Project-URL: Homepage, https://github.com/AmirKenzo/ak-cli
Project-URL: Repository, https://github.com/AmirKenzo/ak-cli
Project-URL: Issues, https://github.com/AmirKenzo/ak-cli/issues
Author: AmirKenzo
License-Expression: MIT
License-File: LICENSE
Keywords: backup,cli,monitoring,server,sysadmin,telegram
Classifier: Development Status :: 3 - Alpha
Classifier: Environment :: Console
Classifier: Intended Audience :: System Administrators
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: OS Independent
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3 :: Only
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 :: Systems Administration
Classifier: Topic :: Utilities
Requires-Python: <3.15,>=3.11
Requires-Dist: kurigram>=2.0
Requires-Dist: psutil>=5.9
Requires-Dist: rich>=13.0
Requires-Dist: tgcrypto>=1.2
Description-Content-Type: text/markdown

# akctl

A small CLI I built for my own server management needs — quick answers to
"what's using the RAM", "is this port open", "how full is the disk", without
reaching for a full monitoring stack. Sharing it in case it's useful to
someone else too.

Every command works both as a direct CLI call and from an interactive menu,
so you can script it or just run `ak` and pick from a list.

## Features

| Command         | Description                                   |
| --------------- | ---------------------------------------------- |
| `system-info`   | OS, architecture, Python version, hostname     |
| `disk-usage`    | Usage for every mounted disk/partition         |
| `network-info`  | IPv4 address of every network interface        |
| `memory-info`   | RAM and swap usage                             |
| `cpu-info`      | Core count, current usage, frequency           |
| `process-list`  | Top processes by memory usage                  |
| `uptime`        | System boot time and uptime                    |
| `users`         | Currently logged-in users                      |
| `port-check`    | Check whether a TCP port on a host is open     |
| `backup-init`   | Create a backup config template                |
| `backup`        | Archive configured folders and send to Telegram|

## Requirements

- Python 3.11+

## Installation

Clone the repo and install it in a virtual environment. [uv](https://docs.astral.sh/uv/)
is recommended:

```bash
git clone https://github.com/AmirKenzo/ak-cli.git
cd ak-cli
uv sync
uv run ak
```

Or with plain `pip`:

```bash
git clone https://github.com/AmirKenzo/ak-cli.git
cd ak-cli
python -m venv .venv
.venv/Scripts/activate   # on Linux/macOS: source .venv/bin/activate
pip install -e .
ak
```

## Usage

Running `ak` with no arguments opens the interactive menu:

```bash
ak
```

Every command is also available directly, which is handy for scripts and
one-liners:

```bash
ak system-info
ak disk-usage
ak memory-info
ak cpu-info
ak process-list --limit 5
ak port-check example.com 443
ak uptime
ak users
```

### Backups

`ak backup` archives an explicit target — a known type or a folder path — into
a `.tar.gz` and sends it to a Telegram chat via [Kurigram](https://pypi.org/project/Kurigram/)
(a maintained Pyrogram fork; imported as `pyrogram`). Its `tgcrypto` dependency
gives it fast native crypto, so uploads are noticeably quicker than
pure-Python alternatives. A target is always required, so it never silently
sends something you didn't ask for:

```bash
ak backup                    # error: target is required
ak backup pasarguard         # backs up /opt/pasarguard + /var/lib/pasarguard, nothing else
ak backup /etc/nginx         # backs up an arbitrary folder
ak backup pasarguard --keep  # also save the archive in the current directory
```

Known types live in `BACKUP_TYPES` in [src/ak/backup.py](src/ak/backup.py)
(currently just `pasarguard`); anything else passed as the target is treated
as a literal folder path.

```bash
ak backup-init   # interactive wizard: prompts for telegram creds, saves to ~/.config/ak/backup.json
```

If you skip `backup-init` and just run `ak backup <target>` in a terminal, it
prompts you for the Telegram bot token/chat ID on the spot (and offers to save
them) instead of failing. `api_id`/`api_hash` default to Telegram Desktop's
public API credentials if left unset, so only `bot_token` and `chat_id` are
needed. They can also be passed as flags for one-off/scripted runs:

```bash
ak backup pasarguard --bot-token "<token>" --chat-id -1001234567890
```

Config can also be provided entirely via environment variables — useful for
cron/systemd, where there's no terminal to prompt on:
`AK_TG_API_ID`, `AK_TG_API_HASH`, `AK_TG_BOT_TOKEN`, `AK_TG_CHAT_ID`, and
`AK_BACKUP_CONFIG` to point at a non-default config file location.

The upload is bounded by a hard timeout (`SEND_TIMEOUT_SECONDS`, 900s) so a
blocked/unreachable network fails eventually instead of hanging forever — if
your server can't reach Telegram directly at all (common when self-hosting in
regions that filter it), no client-side setting fixes that; you'd need a
proxy in front of it.

`kurigram` (and its `tgcrypto` speed-up) are core dependencies, installed
automatically with `akctl` — no extra install step needed. `tgcrypto` ships
prebuilt wheels for common platforms; on one without a wheel it needs a C
compiler at install time.

## Roadmap

- Scheduled (cron) backup runs
- Including database dumps alongside the folder backups

## License

MIT — see [LICENSE](LICENSE).
