x-cmd 发行版 - Gitee.com

v0.9.4

2026-05-11 17:43

v0.9.4

[👉 View Full Changelog on X-CMD Website](https://x-cmd.com/v/0.9.4)
[👉 Version compare: v0.9.3...v0.9.4](https://gitee.com/x-cmd/x-cmd/compare/v0.9.3...v0.9.4)

## ✅ Upgrade Guide

```bash 
x upgrade 
```

## 📃 Changelog

![x-cmd-v094](https://codeberg.org/x-cmd/img/raw/branch/main/assets/x-cmd-v094.cn.webp)

### [ccal](https://x-cmd.com/mod/ccal)

- `x ccal` optimized —— better Chinese lunar calendar and holiday handling designed for AI Agents.

- tiaoxiu subcommand: pipe output now uses TSV format (easier for AI parsing), new `--hide-plain-rest` option to exclude plain weekend rest days
- All subcommands add output mode hints: TTY outputs colorful table / Pipe outputs structured data
- Holiday markers clearer: `假` = holiday, `工` = make-up work, `休` = regular weekend
- Data stored locally, downloaded directly, runs offline without any external API dependency

### [humantime](https://x-cmd.com/mod/humantime)

- `x humantime` enhanced —— new millisecond conversion, time range check, and comparison operators.

- New `toms` subcommand: convert time format to milliseconds (e.g., `2h30m` → `9000000`)
- `tosec` new `--decimal` option: fixed 3 decimal places output (e.g., `9000.000`)
- New `in` subcommand: check if seconds are within specified range (great for timeout detection)
- New comparison operators: `gt` (greater than), `lt` (less than), for time comparison logic
- `fromsec` and `tosec` are primary names, `sec` and `tohuman` kept as aliases

### [claw](https://x-cmd.com/mod/claw)

- `x claw` parameter interface overhaul — now supports multiple platforms running simultaneously.

Previously you had to run `x claw service start weixin`, and running multiple platforms meant multiple instances. That was a bit of a hassle.
Now it's `x claw start`, and you can pass `--weixin --telegram` to run several platforms at once.

If you don't specify a platform, it auto-detects logged-in IM platforms and falls back to weixin by default.

Supported platforms: weixin, telegram, feishu, qywx.

```bash
# start weixin and telegram together
x claw start --weixin --telegram

# auto-detect available platforms
x claw start
```

### [qr](https://x-cmd.com/mod/qr)

- `x qr` experimentally provides a pure AWK QR code generation solution with no binary dependencies.

For cross-platform compatibility, the z7/mod/qr module now includes a pure AWK implementation of QR code generation.
No dependencies on qrencode or other external tools — works in any environment with AWK installed.
Core implementation uses gawk/mawk/nawk compatible syntax with posix awk fallback logic.

### [ossinsight](https://x-cmd.com/mod/ossinsight)

- `x ossinsight` experimental module —— CLI tool for GitHub open source project analytics data.

Fetch GitHub trending repos, collection rankings, stargazer history trends, Issue/PR creator stats, country/org distribution via OSSInsight API.
Ideal for quickly checking trends for a project or language in the terminal.

### [umami](https://x-cmd.com/mod/umami)

- `x umami` module upgraded —— full Umami V2 API support with self-hosted compatibility.

Umami V1 API is deprecated (security vulnerabilities). The new CLI fully switches to V2 API (https://api.umami.is/v2).
Cloud users just need to configure their token. Self-hosted users can specify their own endpoint.
New `--profile` feature enables multi-site configuration management.

最后提交信息为： Updating main branch using x7 release -> 3f57e47369b03851280d8b4135...

v0.9.3

3f57e47

2026-05-07 08:56

v0.9.3

[👉 View Full Changelog on X-CMD Website](https://x-cmd.com/v/0.9.3)
[👉 Version compare: v0.9.2...v0.9.3](https://gitee.com/x-cmd/x-cmd/compare/v0.9.2...v0.9.3)

## 📃 Changelog

![x-cmd-v093](https://codeberg.org/x-cmd/img/raw/branch/main/assets/x-cmd-v093.cn.webp)

### [advise](https://x-cmd.com/mod/advise)

- Added `x advise spec` module —— use AI to quickly generate advise.yml for modules or scripts.

Writing module documentation is time-consuming. `x advise spec` handles it for you.
Just describe what the module does, and it generates a properly formatted advise.yml,
sparing you from fiddling with formatting.

### [core](https://x-cmd.com/mod/core)

- Fixed a bug in `pidofsubshell_` on non-bash/zsh environments. Both tmo and service modules depend on it — fixing this benefited several modules at once.

### [timeout](https://x-cmd.com/mod/timeout)

- `x timeout` is now a standalone module, extracted from internal implementation.

It's a portable wrapper around the system `timeout` command with automatic busybox/cosmo fallback, supporting signal selection, kill-after timeout, verbose mode, and more.
Earlier it tried to support `--function` and `--subshell`, but these were dropped — `--function` due to unreliable trap behavior inside shell functions, and `--subshell` moved to the tmo module.

### [tmo](https://x-cmd.com/mod/tmo)

- `x tmo` is now a standalone module, originating from timeout's `--subshell` feature.

tmo's core is subshell timeout control. Previously it used an fp file to pass pid and fingerprint between worker and watchdog — file I/O and uuid generation overhead was significant. Later refactored to use outer subshell local variables directly, eliminating file operations and simplifying the logic.
`--function` support was ultimately dropped — trap behavior inside shell functions proved too unreliable across different call contexts.

### [humantime](https://x-cmd.com/mod/humantime)

- `humantime tosec` now supports fractional seconds — `1.5s`, `0.5m` and similar formats all convert correctly.
Previously in bash3, dash, ash and other environments where $(()) doesn't support decimals, only integers worked. After several rounds of refinement, it now handles all environments correctly.

### [bfind](https://x-cmd.com/mod/bfind)

- `x bfind` is now a standalone module, extracted from x-cmd core.
Previously part of the core command set, now separated out to provide clearer file search and locate functionality.

### [tlfz](https://x-cmd.com/mod/tlfz)

- `x tlfz` is now a standalone module, extracted from `x tdlr`.
Fzf-style fuzzy search functionality, now provided as a standalone module with clearer responsibilities and more flexible configuration.

### [ps](https://x-cmd.com/mod/ps)

- Added `x ps tree` subcommand to display process tree using BFS traversal.
This feature is designed for kill tree — killing a process tree requires knowing the full process hierarchy first.

### [kill](https://x-cmd.com/mod/kill)

- Added `x kill tree` subcommand to recursively kill a process and all its children.
This feature is designed for x tmo — when tmo kills a subshell, it needs to clean up the entire process tree to avoid leaving orphaned processes.

最后提交信息为： Updating main branch using x7 release -> 09c9538bf4ee6be48a560ea51f...

v0.9.2

09c9538

2026-05-02 18:54

v0.9.2

[👉 View Full Changelog on X-CMD Website](https://x-cmd.com/v/0.9.2)
[👉 Version compare: v0.9.1...v0.9.2](https://gitee.com/x-cmd/x-cmd/compare/v0.9.1...v0.9.2)

## 📃 Changelog

![x-cmd-v092](https://codeberg.org/x-cmd/img/raw/branch/main/assets/x-cmd-v092.cn.webp)

### [hub](https://x-cmd.com/mod/hub)

- `x hub` now supports email binding and sharing entire static sites.

Previously, sharing a static page or project meant one file per link.
Now just zip up your folder, upload to cloud, one command gives you a working shareable link — with custom entry file and optional expiration.

Email binding also available so you get important messages and alerts in time.

```bash
# bind an email address for notifications
x hub bind email user@example.com

# zip up an AI-generated static blog or portfolio, generate a shareable link in one shot
x hub file share zip ./dist.zip

# specify entry (e.g. main.html) and expiration, share with colleagues or clients
x hub file share zip --entry main.html --expires 3600 ./dist.zip
```

### [service](https://x-cmd.com/mod/service)

- Added `x service` module —— claw daemon needs a solid service layer to stay running reliably in the background.

Previously, start/stop, status, and logs were scattered across different places, and tweaking configs meant digging into systemctl.
service brings them together — start/stop/restart/status/log/isalive/pause/resume/rm in one command, service names with or without .service suffix.

```bash
# start a service (e.g. nginx)
x service start nginx

# check service running status
x service status nginx

# stream real-time service logs
x service log nginx
```

### [worker](https://x-cmd.com/mod/worker)

- Added `x worker` module —— when multiple agent tasks are running in the background, you need to know who's alive and who's gone.

As tasks pile up, checking PID, uptime, or whether it's still running is a hassle.
worker isolates each task with namespace and process fingerprint, so isalive verifies, info shows details, and ls lists all.

```bash
# start a background worker running a python agent
x worker run --name mytask -- python agent.py

# check if the worker is still alive
x worker isalive --name mytask

# view worker details including PID and start time
x worker info --name mytask
```

### [claw](https://x-cmd.com/mod/claw)

- `x claw` now supports sending and receiving images and files —— Weixin, Feishu, and Telegram are all wired up.

Previously it was text-only, so sharing a screenshot or document meant figuring out another way.
Now you can attach files directly, including images, PDFs, and logs. The commands stay the same, no new flags needed.

```bash
# start weixin service
x claw service start weixin
```

### [tailer](https://x-cmd.com/mod/tailer)

- Added `x tailer` module —— claw agents communicate via A2A protocol, and this is the message broker underneath.

No external message queue needed — the directory itself is the queue, multi-writer single-reader model.
run to listen, send to post, pending to check backlog, sub/pub to manage subscriptions. GC threshold cleanup and one-shot subscriptions also supported.

```bash
# start a message queue listener, continuously processing messages
x tailer run /tmp/mq

# send a message to the queue
x tailer send /tmp/mq "hello"

# check how many messages are currently backlogged
x tailer pending /tmp/mq
```

最后提交信息为： Updating main branch using x7 release -> 6f596f49ad2c8a4e8995170cbb...

v0.9.1

6f596f4

2026-04-29 00:30

v0.9.1

[👉 View Full Changelog on X-CMD Website](https://x-cmd.com/v/0.9.1)
[👉 Version compare: v0.9.0...v0.9.1](https://gitee.com/x-cmd/x-cmd/compare/v0.9.0...v0.9.1)

## ✅ Upgrade Guide

```bash 
x upgrade 
```

## 📃 Changelog

![x-cmd-v091](https://codeberg.org/x-cmd/img/raw/branch/main/assets/x-cmd-v091.cn.webp)

### [curl](https://x-cmd.com/mod/curl)

- From v0.9.1, x-cmd no longer provides a bundled fallback curl for Windows by default (Linux remains unchanged — if curl is not available locally, x-cmd will still use its self-compiled curl).

The reason is that Windows Device Guard blocks x-cmd's self-compiled curl — we encountered this issue on a Xiaomi notebook.

Previously, we defaulted to x-cmd's curl because users had reported certificate issues with Windows' native curl.

If you encounter curl issues on Windows, you have two options:
1. Use a newer version of Git for Windows (v2.40+) which has curl v8.12.
    Or update your Windows system where the built-in curl is already v8.12.
2. Run `x winget install curl` to update your system's curl via winget.

### [uuid](https://x-cmd.com/mod/uuid)

- Buying a Windows laptop and returning to heavy Windows use after many years revealed quite a few git-bash compatibility issues — one of them being that git-bash has essentially no UUID support.
This drove improvements to the UUID module: the code originated from the rand module (3-4 years ago), and this version greatly simplifies the implementation with fewer forks and lower memory overhead, while adding UUIDv4 support.
v4 and v7 each suit different scenarios: use v4 (`x uuid get`) when you need stronger randomness and want to conceal generation time; use v7 for ordered scenarios like logging and sorting. A `parsev7` command is also provided to extract time information from v7.
The implementation is concise enough to clearly explain UUID principles to users. Consult the standard via `x rfc 9562` (RFC 9562 defines all 8 UUID versions).

### [epoch](https://x-cmd.com/mod/epoch)

- The epoch module adds `ms`/`ms_` for millisecond timestamps, providing the underlying capability for UUIDv7's time prefix.
Previously, timestamp logic was scattered across multiple modules and went through several rounds of rework. This version finally consolidates it into the epoch module — UUIDv7 no longer needs to compute timestamps on its own.

### [claude](https://x-cmd.com/mod/claude)

- Adjusted `x claude use` config — activate DeepSeek-V4-Pro Max reasoning and 1M context to unleash the full power of the best domestic coding model.

Many users forget to enable max reasoning mode and the 1M context window when using DeepSeek V4, leaving V4-Pro's core capabilities on the table.
So we took care of it for you. `x claude use ds` now handles three things at once:
- Sets the model to `deepseek-v4-pro[1m]`, activating the million-token context window
- Cranks reasoning to `max` — a significant boost for complex algorithms and multi-file refactors
- Routes sub-agents to `deepseek-v4-flash`, offloading lightweight tasks to balance speed and cost

```bash
# Configure DeepSeek V4 model
x deepseek --cfg model=deepseek-v4-pro

# Max mode and 1M context configured — every `claude` session auto-uses it
x claude use ds
```

最后提交信息为： Updating main branch using x7 release -> 0338611dc57b1c59e5d8d70808...

v0.9.0

0338611

2026-04-26 03:06

v0.9.0

[👉 View Full Changelog on X-CMD Website](https://x-cmd.com/v/0.9.0)
[👉 Version compare: v0.8.14...v0.9.0](https://gitee.com/x-cmd/x-cmd/compare/v0.8.14...v0.9.0)

## 📃 Changelog

![x-cmd-v090](https://codeberg.org/x-cmd/img/raw/branch/main/assets/x-cmd-v090.cn.webp)

### [clawhub](https://x-cmd.com/mod/clawhub)

- Added the `clawhub` module — enabling global users to smoothly download popular clawhub skills.

Different regions have vastly different network environments, and directly accessing clawhub.ai may not be smooth for some users.
Now `x clawhub` automatically selects the optimal data source based on your network environment:
- Users in mainland China → routed to ByteDance/Volcano Engine mirror (cn.clawhub-mirror.com)
- International users → direct connection to OpenCLAW official platform (clawhub.ai)

```bash
# Search for skills containing "http"
x clawhub search "http"

# View skill details
x clawhub skill get ontology

# Download skill to local
x clawhub download ontology -o ./ontology.zip
```

### [skill](https://x-cmd.com/mod/skill)

- Chinese users downloading skills from ClawHub via `x skill add` will now automatically route through the ByteDance/Volcano Engine mirror for accelerated downloads.
Additionally, the `ll` command has been officially renamed to `ls-remote` with the alias `lr`. The previous name `ll` was confusing — it wasn't clear whether it meant "list long" or "list last". Now the name directly conveys its purpose.

```bash
# Download skills from ClawHub
x skill add clawhub/skill-vetter clawhub/ontology

# List skills in a GitHub repo
x skill lr --github https://github.com/google-gemini/gemini-skills
```

### [claw](https://x-cmd.com/mod/claw)

- `claw` module update — by default, it can read OpenCLAW data memory files from the current environment and fixed some issues with `x claw service`, added skill discover mechanism.

Now claw automatically reads OpenCLAW data memory files from your environment — no extra setup needed to reuse what you already have.

Also, claw now supports the skill discover mechanism for automatically discovering and managing skills.

Fixed a few issues with `x claw service`. Should be more stable now.

```bash
# Start weixin service
x claw service start weixin
```

If you find any issues, file an issue and I'll look into it.

### [deepseek](https://x-cmd.com/mod/deepseek)

- `deepseek` added `deepseek-v4` support — same as above, haven't had time to really dig in yet.

DeepSeek dropped a new model, so I added the capability. Now you can specify `deepseek-v4` to try out the latest stuff.

```bash
# Use deepseek-v4-flash model
@ds --model deepseek-v4-flash "Hello, please introduce yourself"
```

If you find it works well for you, feel free to share your experience.

最后提交信息为： Updating main branch using x7 release -> 58c39378780f2f454a596624c4...

预览版本

v0.8.15

58c3937

2026-04-23 02:40

v0.8.15

[👉 View Full Changelog on X-CMD Website](https://x-cmd.com/v/0.8.15)
[👉 Version compare: v0.8.14...v0.8.15](https://gitee.com/x-cmd/x-cmd/compare/v0.8.14...v0.8.15)

## 📃 Changelog

![x-cmd-v0815](https://codeberg.org/x-cmd/img/raw/branch/main/assets/x-cmd-v0815.cn.webp)

### [claw](https://x-cmd.com/mod/claw)

- X-Claw major upgrade.

Agents used to avalanche-retry on consecutive failures; now there's circuit breaker cooldown with auto-recovery, and heartbeats are quieter too —— idle Agents self-acknowledge, cutting pointless polling.

Cron task prompts are standardized across platforms, and message delivery is more reliable. Added `x claw service` for background daemon setup with auto-start and crash recovery —— set it and forget it.

Skill support is also expanded: Agents can now load both global and conversation workspace skills, so instructions from different sources stack together —— no more shuffling files around.

```bash
x claw service start weixin
```

### [skill](https://x-cmd.com/mod/skill)

- `x skill add` has expanded its download sources — now supports installing skills directly from GitHub and Clawhub.

Some users wanted to try popular and practical community skills, but previously could only download skills from the x-cmd/skill registry — the selection was too limited. Now you can install popular skills directly from Clawhub, or batch-download and install skills from GitHub repositories.

```bash
# Install self-improving-agent and ontology skill from Clawhub
x skill add clawhub:self-improving-agent clawhub:ontology

# Add multiple skills from a GitHub repository
x skill add https://github.com/google-gemini/gemini-skills --skill gemini-api-dev --skill gemini-interactions-api

# List the skills in the GitHub repository
x skill ll --github https://github.com/google-gemini/gemini-skills
```

### [cron](https://x-cmd.com/mod/cron)

- Added `x cron` module —— foundational utility for cron jobs, used by claw and available to other modules.

Standard expressions, directory-based storage, namespace isolation, timezone support. Run as service, debug in foreground, catch up with runonce, or exec directly. claw is already using it.

```bash
x cron add --name myjob "*/5 * * * *" "echo hello"
x cron ls
x cron service start
```

### [free](https://x-cmd.com/mod/free)

- Added `--expert` mode for detailed system info —— no more flipping through /proc manually.

The default free output just doesn't cut it when you need to dig deeper. Kernel params, LRU hit rates, THP settings, IO stats, VM layout, hardware utilization —— usually means juggling a bunch of commands or reading /proc manually.

Threw in a `-e` flag to get all that with one shot.

```bash
# Expert mode: kernel, LRU, THP, IO, VM, hardware stats
x free -e
```

最后提交信息为： Updating main branch using x7 release -> 5cbe7f73019fb7b3f78d6fe78f...

v0.8.14

5cbe7f7

2026-04-19 04:02

v0.8.14

[👉 View X-CMD blog for more information about this version](https://x-cmd.com/blog/260419)
[👉 View Full Changelog on X-CMD Website](https://x-cmd.com/v/0.8.14)
[👉 Version compare: v0.8.13...v0.8.14](https://gitee.com/x-cmd/x-cmd/compare/v0.8.13...v0.8.14)

## ✅ Upgrade Guide

```bash 
x upgrade 
```

## 📃 Changelog

![x-cmd-v0814](https://codeberg.org/x-cmd/img/raw/branch/main/assets/x-cmd-v0814.cn.webp)

### [feishu](https://x-cmd.com/mod/feishu)

- Added `abot` command — gives `x claw` the ability to send messages to Feishu.

x claw wanted to proactively send messages to Feishu but had no convenient way to do it.
`abot send` solves that — text, images, files, all supported. Pair it with x claw and AI replies can now be pushed to Feishu groups.

```bash
# Send text message
x feishu abot send --text --chatid <chat_id> "Hello"
# Send image
x feishu abot send --image --chatid <chat_id> /path/to/img.png
# Send file
x feishu abot send --file --chatid <chat_id> /path/to/file.pdf
```

### [hw](https://x-cmd.com/mod/hw)

- Added `hw` module — pull all peripheral info at once, quickly size up a machine's hardware.

SSH into an unfamiliar machine and want to know what peripherals it has — Bluetooth, camera, battery, Thunderbolt... checking them one by one is tedious.
`x hw` pulls everything at once: overview table plus network interfaces, so you can quickly get a read on a machine's hardware. Plugged in something new and not sure if it's recognized? Run `x hw ls` and check.

```bash
# peripheral overview + network interfaces
x hw
# detailed peripheral info
x hw info
# compact table
x hw ls
```

### [gpu](https://x-cmd.com/mod/gpu)

- Added `gpu` module — hardware info and real-time load in one view.

Checking GPU load on macOS is surprisingly hard — System Report only has hardware info, and Activity Monitor doesn't show GPU utilization. When running models or debugging graphics, you often want to know if the GPU is actually doing anything.
`x gpu` combines hardware info and real-time load: model, core count, Metal version, followed by GPU utilization and memory usage.

```bash
# hardware info + real-time load
x gpu
# hardware info only
x gpu info
# real-time load only
x gpu stat
```

### [cpu](https://x-cmd.com/mod/cpu)

- Added `cpu` module — key fields laid out cleanly, no more digging through sysctl.

Scripts sometimes need CPU info for branching logic: how many cores, what architecture, P-core vs E-core counts. `sysctl -a | grep cpu` floods the terminal — the useful fields are buried in there.
`x cpu info` picks out the key fields. `x cpu stat` shows real-time load down to per-core utilization. There's also `x cpu endianness` for byte order detection — handy for cross-compilation.

```bash
# hardware info + real-time load
x cpu
# hardware info only
x cpu info
# real-time load only
x cpu stat
# detect byte order
x cpu endianness
```

### [disk](https://x-cmd.com/mod/disk)

- Added `disk` module — APFS containers auto-merged, grouped by physical disk, no more volume confusion.

The most annoying thing about df on macOS is how APFS containers split one disk into multiple volumes — df shows five or six mount points that add up to more than the actual disk capacity. Confusing.
`x disk stat` groups by physical disk, auto-merging volumes from the same APFS container. You can actually tell how full each disk is. Hardware info (model, SMART status, partition table) is included too — no need to run system_profiler separately.

```bash
# hardware info + usage table
x disk
# usage only
x disk stat
# list disks and partitions
x disk ls
```

### [wifi](https://x-cmd.com/mod/wifi)

- Added `wifi` module — not just viewing info, but scanning, connecting, and managing saved networks.

This isn't just for viewing WiFi info — `x wifi scan` sweeps nearby APs, `x wifi connect` joins a network, and `x wifi prefer ls` manages saved networks. Signal strength is color-coded, so you don't have to guess which one's stronger.
When doing on-site ops or helping someone troubleshoot network issues, no need to memorize those long platform-specific commands anymore.

```bash
# adapter info + available networks
x wifi
# scan nearby networks
x wifi scan
# connect to WiFi
x wifi connect SSID password
# saved networks
x wifi prefer ls
```

### [usb](https://x-cmd.com/mod/usb)

- Added `usb` module — speeds labeled as 12M, 480M, 5G, 10G, tell device specs at a glance.

ioreg output is basically unreadable. lsusb is better but shows speeds as raw values — you have to figure out USB 2.0 vs 3.0 yourself.
`x usb` labels speeds directly as 12M, 480M, 5G, 10G — tell at a glance what speed each device is running at. Detailed info and compact table output together, no switching back and forth.

```bash
# detailed info + compact table
x usb
# detailed info only
x usb info
# compact table only
x usb ls
```

### [display](https://x-cmd.com/mod/display)

- Added `display` module — multi-monitor info laid out clearly, plus real-time brightness per screen.

With multiple monitors plugged in, figuring out which is which, what resolution, and what port it's connected through means digging through system settings.
`x display` lays it all out — resolution, refresh rate, connection type, whether it's the main display, all in one table. `x display stat` shows real-time brightness per screen.

```bash
# detailed info + compact table
x display
# compact table only
x display ls
# real-time brightness
x display stat
```

### [claw](https://x-cmd.com/mod/claw)

- Added `claw` module —— honestly, I built this because I hated wasting money on coding plan subscriptions I could only use in the terminal.

Wanted a personal AI assistant running on my own device, accessible from WeChat or Telegram whenever I need it.
`claw` is exactly that. Its internal AI engine can connect to model vendors' own AI Agent tools — claude, codex, gemini-cli, opencode, kimi-cli all work, use whichever subscription you have.

Not just chat, but professional Coding Agents that can edit code and run commands. Each chat gets its own workspace with persistent context memory, and multiple sessions can run concurrently without stepping on each other.

WeChat and Telegram are already working. Feishu and enterprise WeChat are on the way. We'll also be integrating x-cmd's own ai agent chat directly, so you won't need external engines.

It's still early days. Give it a try — maybe it'll become something you can't live without too.

```bash
# start WeChat message listener
x claw Run
# start Telegram message listener
x claw run telegram
```

最后提交信息为： Updating main branch using x7 release -> ac230d0457d8d6ba726e5e57c4...

v0.8.13

ac230d0

2026-04-12 21:36

v0.8.13

[👉 Version compare: v0.8.12...v0.8.13](https://gitee.com/x-cmd/x-cmd/compare/v0.8.12...v0.8.13)

## 📃 Changelog

![x-cmd-v0813](https://codeberg.org/x-cmd/img/raw/branch/main/assets/x-cmd-v0813.cn.webp)

### [free](https://x-cmd.com/mod/free)

- Added process memory display to `free` —— previously could only check total system memory.

When troubleshooting, you often need to see which specific process is consuming memory. System overview alone is not enough.

Now `x free` outputs system memory by default, sorted by memory usage — spot the suspect process at a glance.

```bash
# Show memory usage and system overview
x free

# Show all processes
x free --top all
```

### [feishu](https://x-cmd.com/mod/feishu)

- Added the `react` command — turns the Feishu bot into a repl bot.

The idea of running commands right from Feishu has been around for a while, and now it's finally working. Enable repl mode and any message you receive gets treated as a command, with the result pushed back.

We'll add Agent running capability next.

Example:
```bash
# Start interactive REPL mode, execute received messages as commands and return results
x feishu react --runner repl
```

### [telegram](https://x-cmd.com/mod/telegram)

- Added the `react` command — can directly execute commands in Telegram and return results.

Post a command in the group, it runs and pushes back the result. Supports automatic image and file download — screenshot posted in group saves to local automatically.

```bash
# Start interactive REPL mode, execute received messages as commands and return results
x telegram react --runner repl
```

### [uuid](https://x-cmd.com/mod/uuid)

- Added `uuid` module —— now officially available as a foundational library.

When scripting, you often need a "unique ID that won't collide".
Previously you might hunt for uuidgen or cobble together timestamps with random numbers — hassle.

Now just `x uuid`, one command gives you a standard v4, ready to use.
There's also v7, which bakes the timestamp right into the ID, naturally time-ordered.
Great for database keys or logging — query performance beats v4.

```bash
# Quick unique ID
x uuid

# Time-ordered, great for database keys
x uuid v7
```

### [date](https://x-cmd.com/mod/date)

- Added `date` module —— now officially available as a foundational library.

Handling time in scripts has always been painful: getting current time, format conversion, calculating differences, processing timestamps — each requires checking command manuals.
Now unified in one module.

Supports ISO, string (filename-friendly), variable name, UTC short format and more.
Handles second, millisecond, and decimal timestamps, plus calculates days between dates.

```bash
# Current time in ISO format
x date

# Filename-friendly format
x date str

# Convert timestamp to ISO
x date iso 1743038674

# Days until a specific date
x date diff '2026-01-01'
```

最后提交信息为： Updating main branch using x7 release -> 77bb6e1477492235b44b23224c...

v0.8.12

824c1cd

2026-04-03 17:20

v0.8.12

[👉 Version compare: v0.8.11...v0.8.12](https://gitee.com/x-cmd/x-cmd/compare/v0.8.11...v0.8.12)

## 📃 Changelog

![x-cmd-v0812](https://codeberg.org/x-cmd/img/raw/branch/main/assets/x-cmd-v0812.cn.webp)

### [agent](https://x-cmd.com/mod/agent)

- The `agent` module now has `request` and `job` subcommands —— the focus this time is making agent capabilities composable.

We've split single-shot calls and task iteration into standalone building blocks. The next step is making these blocks composable, so they can be wired together into agent workflows that fit different needs.

Two new capabilities landed:
- `x agent request`: Single-shot requests for simple tasks. Send a prompt and get a response right away, with optional file attachments
- `x agent job`: Long-running tasks that AI iterates on for you. Just throw in a requirement — the AI will talk it through with you, generate a TODO.md, and automatically execute step by step. Change your mind mid-way? No problem. And when tasks pile up, you can list them all at a glance

Examples:
```bash
# Single request with an attached file
x agent request -f main.py "Review this code"

# Create a long-term task; the AI will clarify requirements with you
x agent job init "Add unit tests and set up CI"

# AI automatically iterates through the TODO
x agent job iter

# Requirements changed? The AI updates the TODO
x agent job adjust "Add integration tests too"

# See what tasks are in progress
x agent job ls
```

Feedback and issue reports are always welcome.

### [weixin](https://x-cmd.com/mod/weixin)

- Added the `react` command — turns the WeChat ClawBot into a repl bot.

The idea of running commands right from WeChat has been around for a while, and now it's finally working. Enable repl mode and any message you receive gets treated as a command, with the result pushed back.

We'll add Agent running capability next.
Examples:
```bash
# Start interactive REPL mode, executing messages as commands and returning output
x weixin react --runner repl
```

- Fixed a bug where sending files and images would fail — WeChat changed their data format and our parsing logic didn't keep up.

### [docker](https://x-cmd.com/mod/docker)

- Fixed the `refit` issue — when the base image user exists but the home directory is missing, the image build would fail.
Thanks to @yyq19990828 for the bug report in #394.

最后提交信息为： Updating main branch using x7 release -> 6535f2be86380abc9c736e1b65...

v0.8.11

7c240cc

2026-03-27 06:49

v0.8.11

[👉 View X-CMD blog for more information about this version](https://x-cmd.com/blog/260327)
[👉 Version compare: v0.8.10...v0.8.11](https://gitee.com/x-cmd/x-cmd/compare/v0.8.10...v0.8.11)

## ✅ Upgrade Guide

```bash 
x upgrade 
```

## 📃 Changelog

![x-cmd-v0811](https://codeberg.org/x-cmd/img/raw/branch/main/assets/x-cmd-v0811.cn.webp)

### [weixin](https://x-cmd.com/mod/weixin)

- Added `weixin` module —— supports Tencent's iLink Bot API.

In 2026, Tencent opened an official Bot API for personal WeChat accounts via OpenClaw, and we've integrated it. The old ways — reverse-engineering protocols or hooking clients — carried real risk. Now it's the official server `ilinkai.weixin.qq.com` with proper terms.

Supported features:
- QR login with local credential storage
- Long-poll message receiving
- Send text, images, files, videos

Usage:
```bash
x weixin login                      # Scan QR to login
x weixin listen poll                # Listen for messages
x weixin send text "Hello"
x weixin send image /path/to/img.jpg
x weixin send file /path/to/doc.pdf
```

Tencent's terms mention they "may interrupt service at any time," so don't bet critical business on it. Feedback welcome.

### [shortcut](https://x-cmd.com/mod/shortcut)

- Default `free` alias on macOS pointing to `x free` —— native implementation with physical memory and macOS's compressed memory info.

shortcut works across ash, bash, fish, zsh — set it up once and you're good everywhere. Handy for aliasing commands you use often.

Example:
```bash
x shortcut default
free
```

### [p7zip](https://x-cmd.com/mod/p7zip)

- Fixed `p7zip` module —— resolved write error when compressing folders to tar.gz.

最后提交信息为： Updating main branch using x7 release -> 4336d0ac31742f0900b5ad3a01...

v0.8.10

4336d0a

2026-03-26 15:14

v0.8.10

[👉 Version compare: v0.8.9...v0.8.10](https://gitee.com/x-cmd/x-cmd/compare/v0.8.9...v0.8.10)

## 📃 Changelog

![x-cmd-v0810](https://codeberg.org/x-cmd/img/raw/branch/main/assets/x-cmd-v0810.cn.webp)

### [shortcut](https://x-cmd.com/mod/shortcut)

- Open-sourced `shortcut` module —— was internal, now available for everyone.

Configure once, works across ash, bash, fish, zsh and more. Set short aliases for frequent commands, like `xd` for `x docker`.

Common examples:
```bash
x shortcut set --x-cmd docker xd      # alias xd to x docker
x shortcut set --cmd 'ls -lah' ll     # alias ll to ls -lah
x shortcut ls                         # list all shortcuts
```

### [whisper](https://x-cmd.com/mod/whisper)

- The whisper module now has a `livekit` command — automatically installs dependencies and quickly launches WhisperLiveKit.

WhisperLiveKit has a ton of dependencies: PyTorch, ffmpeg, MLX (Apple Silicon), various optional components. Installing them manually is a hassle. We handle everything for you, one command to get started:
```bash
# Auto-detects your environment, installs the right dependencies, then starts the server.
x whisper livekit run

# Transcribe an audio file (no server needed).
x whisper livekit transcribe meeting.mp3
```

Honestly, I haven't had deep hands-on time with WhisperLiveKit yet, but it's pretty promising: Simul-Whisper/Streaming for low-latency transcription, speaker diarization, Voxtral Mini, and simultaneous translation.
Give it a try and share your feedback — help us iterate and improve it.

### [x-cmd](https://x-cmd.com/mod/x-cmd)

- Optimized `x-cmd` module help output —— 300+ commands is a lot to scroll through.

Now `x -h` shows a condensed view with just 5 items per category, plus a hint to use `--help` for the full list. We'll roll this out to other modules gradually.

Example:
```bash
x -h          # Concise mode, 5 items per category
x --help      # Full mode, all commands
```

### [7z](https://x-cmd.com/mod/7z)

- Fixed `7z` module —— now checks for local 7z before downloading.

Previously `x 7z` would go straight to the network, even if 7z was already installed. Thanks to @Leaderzhangyi for pointing this out in #389.

最后提交信息为： Updating main branch using x7 release -> bc9176face3c5b22a87792f2e1...

v0.8.9

01ac972

2026-03-22 01:14

v0.8.9

[👉 View X-CMD blog for more information about this version](https://x-cmd.com/blog/260322)
[👉 Version compare: v0.8.8...v0.8.9](https://gitee.com/x-cmd/x-cmd/compare/v0.8.8...v0.8.9)

## 📃 Changelog

![x-cmd-v089](https://codeberg.org/x-cmd/img/raw/branch/main/assets/x-cmd-v089.cn.webp)

### [agent](https://x-cmd.com/mod/agent)

- Experimental `agent` module —— scaffold first, iterate as we go.

AI tools like Claude, Codex, Kimi, and Opencode each have their own config formats.
Setting up x-cmd prompts repeatedly for each one isn't ideal.

So we built a unified entry point:
- `x agent setup` —— one-click setup for mainstream AI tools to use x-cmd prompts and skills
- `x agent unify` —— merge all AI tool configs into ~/AGENTS.md with symlink management

Example:
```bash
# Interactive AI tool configuration
x agent setup

# Merge config files
x agent unify
```

This is an early-stage experimental feature.
Try it out and let us know what you think — feedback helps us improve.

### [bakman](https://x-cmd.com/mod/bakman)

- Added `bakman` module —— a backup file manager for x-cmd core library.

Some x-cmd internal features needed file backups, but each was doing its own thing without a unified approach.
So I built a base module for internal reuse — but also exposed it to users, because everyone needs backup and restore sooner or later.

Current features are pretty basic:
- `x bakman backup <file>` —— create timestamped backup
- `x bakman restore <file> [version]` —— restore specific version
- `x bakman list [file]` —— list backups
- `x bakman clean <file> [keep]` —— clean old backups
- `x bakman latest <file>` —— show latest backup path

Backups are stored under `$___X_CMD_ROOT_DATA/bakman/` with original path structure.

Example:
```bash
# Backup config file
x bakman backup ~/.bashrc

# Restore from backup
x bakman restore ~/.bashrc

# List backups
x bakman list
```

This is just the beginning — features are intentionally simple for now. File an issue if you need more backup management features.

### [free](https://x-cmd.com/mod/free)

- Upgraded the `free` module — the previous output wasn't intuitive enough, making it hard for users to see at a glance which memory was actually available.

This time I took the time to sort out the logic:
- Standardized terminology for kernel and physical layers (e.g., Logical → Detail, Physical → vm_stat).
- Added color coding: green for available, yellow for cached, red for used.
- Also added a hardware column to show reserved memory, and renamed `Mem free` to the more intuitive `reusable`.

I've been using it for a while — the output is much more intuitive now, and I also refactored the CSV/TSV output. Feel free to give feedback if you run into any issues.

### [root](https://x-cmd.com/mod/root)

- Added `x root dotconfig` —— better integration with your dotfiles workflow.

Many users manage their configs with tools like chezmoi, but x-cmd's directory structure wasn't quite compatible.
Now you can map configurations to ~/.config/x-cmd-cfg with a single command for standardized Infrastructure as Code:

- `x root dotconfig activate` —— Deep integration: map configs to ~/.config/x-cmd-cfg, any XDG-compliant tool can manage them
- `x chezmoi add $___X_CMD_ROOT_CFG` —— Lightweight backup: keep existing structure, track only core configs

While demonstrated with chezmoi, this feature works with all major dotfiles management tools.

### [cutt](https://x-cmd.com/mod/cutt)

- Added `cutt` module documentation —— because awk is overkill for simple data table queries.

Daily needs like extracting specific rows and columns from a data table require awk syntax, commands get long — like `awk 'NR>3{ print $1, $5, $6 }'`.
Different scenarios need delimiter adjustments, negative indexing, range selection — writing these repeatedly is exhausting.

x cutt simplifies this, purpose-built for "select rows and columns from data table" tasks:

```bash
# From ASCII table, select rows 100 to -10, and columns 1, 3, and 6 onward
x ascii | x cutt 100:-10 1,3,6:

# Select column 2 from rows 1 to 3
echo 'a1 a2 a3
b1 b2 b3
c1 c2 c3' | x cutt 1:3 2

# Select column 2 from rows 1 and 3
echo 'a1 a2 a3
b1 b2 b3
c1 c2 c3' | x cutt 1,3 2
```

### [line](https://x-cmd.com/mod/line)

- Added `line` module documentation —— line processing is common in CLI, but sort | uniq has its limits.

`sort | uniq` works fine for basic dedup, but sort needs to sort the entire input first — inefficient for large files.
Need join, wrap, or filter on top of that? Get ready to chain multiple commands.

x line gives you a complete line processing toolkit:
- `uni` —— streaming dedup, faster than sort | uniq
- `duo` / `uno` —— filter for duplicate or unique lines
- `join` —— join lines with delimiter
- `wrap` —— wrap lines with prefix and suffix
- `minus` —— filter out matching lines

```bash
{ seq 1 3; seq 3 1; } | x line uni    # streaming dedup
seq 5 | x line join ", "              # join with comma
seq 10 | x line minus 3 5 7          # filter out 3, 5, 7
```

All common line processing tasks in one place.

最后提交信息为： Updating main branch using x7 release -> b8c688f3ab5aac955f6f594816...

v0.8.8

a0ed47d

2026-03-12 00:05

v0.8.8

[👉 View X-CMD blog for more information about this version](https://x-cmd.com/blog/260311)
[👉 Version compare: v0.8.7...v0.8.8](https://gitee.com/x-cmd/x-cmd/compare/v0.8.7...v0.8.8)

## ✅ Upgrade Guide

```bash 
x upgrade 
```

## 📃 Changelog

![x-cmd-v088](https://codeberg.org/x-cmd/img/raw/branch/main/assets/x-cmd-v088.cn.webp)

### [openclaw](https://x-cmd.com/mod/openclaw)

- Added `--uninstall` command to openclaw module —— clean removal without leftovers.

Several users reported that openclaw's built-in uninstall doesn't remove binary files.
Now with `--uninstall`, it cleans up everything thoroughly.

```bash
# Uninstall OpenClaw, including binary files, gateway service, configuration files, and workspace.
x openclaw --uninstall
```

### [hotkey](https://x-cmd.com/mod/hotkey)

- Added `hotkey` module —— wrote this two years ago, then we forgot about it.

It was 2023, ChatGPT had just blown up. We built Ctrl+X AI command completion in the co module, ran the numbers, and... yeah.
Then silence. The code sat there, nobody mentioned it again.

Things changed. Now Ctrl+X is an AI agent switch, plus we added the fzf family:
- Ctrl+R for history
- Ctrl+T for files
- Alt+C / Esc+C for directory jumping

Try with `x hotkey try` first, then `x hotkey use` to enable permanently.

Examples:
```bash
# Try the co widget (trigger with Ctrl+X)
x hotkey try co

# Permanently enable fzf shortcuts
x hotkey use fzf-history fzf-file fzf-cd
```

### [neo](https://x-cmd.com/mod/neo)

- Added `neo` module —— we've got neofetch-like features, but "Neo" means more than "new".

Look, there are plenty of system info tools out there. But we thought: what does Neo do in The Matrix?
He wakes people up, helps them see the system for what it is.

So `x neo` starts with the basics — OS, kernel, uptime, CPU/GPU/memory, with distro ASCII art logos.
Multiple display modes (mini/std/all/llm/ui), standard and large logos.

But this is just the beginning. Next up: `x neo chat` turns it into a proper AI agent that actively helps you manage and understand your OS.

Examples:
```bash
# Default system info with logo
x neo

# List all supported distro logos
x neo logo ls

# Display large Arch Linux logo
x neo logo large arch

# LLM mode, plain text output for AI consumption
x neo fetch --llm
```

### [ssh](https://x-cmd.com/mod/ssh)

- Added `x ssh setup` command —— finally one-click deploy x-cmd to internal network servers.

Installing x-cmd in air-gapped environments used to be painful: download the package, transfer it, extract, tweak configs — many steps, easy to mess up. Now if you can SSH into the machine, one command handles it all:

```bash
x ssh setup user@hostname
```

After installation, these features work right away on the internal server:
- **Themes & Interaction**: theme customization, smart tab completion, syntax highlighting, enhanced history
- **Filesystem Tools**: enhanced ls, path manipulation, ps process viewer, df disk analyzer
- **Dev Tools**: git enhancements, gitconfig management, githook management, docker shortcuts
- **Local AI**: llmf module to call your locally deployed open-source models

Detailed air-gapped installation guide: https://www.x-cmd.com/start/airgap

Features requiring real-time internet currently don't work offline. We're also exploring solutions for package installation via env — join our group or file an issue if you need this.

最后提交信息为： Updating main branch using x7 release -> 4b2cc2ab48fdc5a2402fdc9edb...

v0.8.7

4b2cc2a

2026-03-09 21:46

v0.8.7

[👉 Version compare: v0.8.6...v0.8.7](https://gitee.com/x-cmd/x-cmd/compare/v0.8.6...v0.8.7)

## 📃 Changelog

![x-cmd-v087](https://codeberg.org/x-cmd/img/raw/branch/main/assets/x-cmd-v087.cn.webp)

### [free](https://x-cmd.com/mod/free)

- Added `free` module documentation —— different systems, wildly different memory commands.

Linux uses free, macOS uses vm_stat, output format and field meanings differ completely.
Writing cross-platform scripts requires separate handling, and macOS memory calculation is much more complex than Linux — has concepts like memory compression, wired, active, inactive, etc.

x free provides a unified entry, auto-detects system, and normalizes output format for you.

```bash
x free              # show memory usage
x free --csv        # CSV format output
x free -s 2         # refresh every 2 seconds
```

Cross-platform scripts no longer need a ton of system detection.

### [claude](https://x-cmd.com/mod/claude)

- A user requested an easier way to use domestic cloud providers' coding plans on Claude Code.
Done! Added three dedicated commands — Alibaba Cloud, Baidu Qianfan, and Tencent Cloud, one-click access guaranteed.

Two ways to use:
1. Standalone commands (recommended): Launch Claude Code and connect to the corresponding provider
   ```bash
   x claude ali        # Launch and connect to Alibaba Cloud
   x claude baidu      # Launch and connect to Baidu Qianfan
   x claude tencent    # Launch and connect to Tencent Cloud
   ```
2. Use command: Switch and permanently configure the model provider for Claude Code
   ```bash
   x claude use ali        # Switch to Alibaba Cloud
   x claude use --project ali   # Write project config, only affects current project
   ```

You can also use `x claude use other` to connect to more third-party model providers (e.g., locally deployed ollama models):
```bash
x claude use other "http://localhost:11434" <api_key> "gpt-oss:20b"
```

Remember to set your API key before using!

最后提交信息为： Updating main branch using x7 release -> af0a2861fed3d7559e6fba7384...

v0.8.6

af0a286

2026-03-08 04:07

v0.8.6

[👉 View X-CMD blog for more information about this version](https://x-cmd.com/blog/260307)
[👉 Version compare: v0.8.5...v0.8.6](https://gitee.com/x-cmd/x-cmd/compare/v0.8.5...v0.8.6)

## ✅ Upgrade Guide

```bash 
x upgrade 
```

## 📃 Changelog

![x-cmd-v086](https://codeberg.org/x-cmd/img/raw/branch/main/assets/x-cmd-v086.cn.webp)

### [openai](https://x-cmd.com/mod/openai)

- Added `gpt-5.4` and `gpt-5.4-pro` support —— OpenAI's new flagship model just dropped, and honestly? It's pretty sweet.

Error rate down 18%, hallucinations cut by 33%. Combines coding and office work in one — code, spreadsheets, presentations, all handled by a single model. Plus the 1M token context window means no more chopping up long docs.

Prices went up (Thinking at $2.5/$15 per million tokens), but OpenAI claims better token efficiency, so it might actually save you money.

Examples:
```bash
# Use gpt-5.4 with all tools enabled
@gpt --model gpt-5.4 --tool all 'Analyze the code structure of this project'

# List supported models
x openai model ls
```

Reference: [OpenAI Official Announcement](https://openai.com/index/introducing-gpt-5-4/)

### [sudo](https://x-cmd.com/mod/sudo)

- Added `sudo` module documentation —— because privilege escalation works differently on every system.

sudo, doas, su all have different usage - Linux typically has sudo, BSD might have doas, some minimal systems only have su - writing scripts means spending time checking which one is available.
Additionally, bare sudo loses PATH env vars, tools installed separately stop working.

x sudo is an enhanced privilege escalation module, auto-selects best available method:
1. Auto fallback: sudo → doas → su, uses whatever's available
2. PATH preservation: custom PATH injected into elevated environment
3. x-cmd available: x-cmd commands work seamlessly under sudo
4. Environment consistency: ___X_CMD_ROOT and other vars preserved

```bash
x sudo apt update              # auto selects sudo/doas/su
x sudo vim /etc/hosts          # edit file with root privileges
x sudo --suuser admin whoami   # use su with specific user
```

Cross-platform scripts no longer need a ton of system detection.

### [os](https://x-cmd.com/mod/os)

- Added `os` module documentation —— because remembering a bunch of commands to check system info is annoying.

uname, arch, uptime, sw_vers... System info scattered everywhere, Linux/macOS/BSD all have different commands.
Checking system type requires a bunch of conditionals, which takes effort in scripts.

x os provides a unified entry point, one command to get all system info, plus is linux/wsl/mac/bsd type checks.

```bash
x os              # view full system info
x os is mac       # check if macOS
x os is linux     # check if Linux
x os is wsl       # check if WSL
```

No more digging through docs to check system type in scripts.

### [hostname](https://x-cmd.com/mod/hostname)

- Added `hostname` module documentation —— because changing hostname requires completely different commands on different systems.

Linux uses hostnamectl, macOS uses scutil, BSD has yet another way.
Writing scripts requires a lot of system detection logic, which is exhausting, and some container environments don't even support these commands.

x hostname handles all systems with one command, auto-detects environment and picks the right approach.

```bash
x hostname                    # view current hostname
x hostname set myhost          # set hostname
```

Cross-platform scripts no longer need a ton of if-else statements.

### [cpu](https://x-cmd.com/mod/cpu)

- Added `cpu` module documentation —— because checking CPU info is scattered everywhere, and detecting endianness requires writing code.

Linux reads /proc/cpuinfo, macOS uses sysctl, Windows is different yet again.
Endianness detection is even more involved - need to write C code or a Python script, a bit heavy.

x cpu shows detailed CPU info, and can directly detect system endianness.

```bash
x cpu info           # view detailed CPU info
x cpu endianness    # detect endianness (l = little, b = big)
```

Super useful for checking endianness in cross-platform scripts.

### [ccmd](https://x-cmd.com/mod/ccmd)

- Added `ccmd` module documentation —— because repeatedly running the same time-consuming command is really wasteful.

curl API calls, complex database queries, time-consuming file processing - wait for full execution every time.
Especially when debugging scripts, running the same command dozens of times, each time waiting idly for results, which is frustrating.

x cmd caches command results with customizable expiration, next execution returns cached result directly.

```bash
x ccmd 1h -- curl https://httpbin.org/get
x ccmd which curl
x ccmd invalidate curl
```

Much more efficient when debugging APIs or making repeated queries.

### [sleep](https://x-cmd.com/mod/sleep)

- Added `sleep` module documentation —— because Cron expressions are too complex for simple scheduled tasks.

Want to run a task every hour? Write `0 * * * *`. Every 30 minutes? `*/30 * * * *`.
Honestly, this format is hard to remember, and many simple cases don't need it at all.

x sleep provides human-readable time formats, beacon for timed output, schd for scheduled execution.

```bash
x sleep 3h30m           # wait 3 hours 30 minutes
x sleep beacon 5m       # output current time every 5 minutes
x sleep schd -i 5m -- make test   # schedule command execution
```

Much more intuitive than Cron for simple cases.

### [fsiter](https://x-cmd.com/mod/fsiter)

- Added `fsiter` module documentation —— pure Shell file iteration, zero external dependencies.

find is powerful but forks external processes. x fsiter is pure Shell, built into x-cmd, saves the process spawn overhead.
Of course, find works fine for daily use — this just gives people who prefer self-contained tools another option.

The interface is intuitive too — --ls --file, --ls --folder, --ls --hidden for clear categorization, no complex parameters to remember.

```bash
x fsiter --ls --file                   # list files only
x fsiter --ls --hidden                  # include hidden files
```

Works out of the box, no extra tools needed.

### [gg](https://x-cmd.com/mod/gg)

- Added `gg` module documentation —— because AI understands your technical questions better than search engines.

Searching for a specific technical problem, search engine returns a bunch of links, you have to click and dig for answers.
AI directly understands your question and gives precise answers, saving the filtering time.

x gg integrates Gemini AI search capability, search directly in terminal with AI.

```bash
x gg "What is x-cmd?"
x gg --md "Explain quantum computing"
x gg --raw "Current bitcoin price"
```

Much more efficient for solving technical problems, AI understanding far exceeds keyword matching.

### [hash](https://x-cmd.com/mod/hash)

- Added `hash` module documentation —— because hash commands are completely different on different systems.

Linux uses md5sum, macOS uses md5, algorithm parameters differ too.
Writing cross-platform scripts means checking which system you're on, which is cumbersome and easy to mess up.

x hash provides a unified cross-platform interface, supports md5/sha1/sha256 and other common algorithms, plus file hash verification.

```bash
x hash md5 file.txt
x hash sha256 file.txt
x hash assert file.txt d41d8cd98f00b204e9800998ecf8427e
```

No more remembering which command to use on which system.

### [hashdir](https://x-cmd.com/mod/hashdir)

- Added `hashdir` module documentation —— because there's no handy tool to calculate hash for an entire directory.

Want to verify if a project directory has been tampered with? Have to hash each file one by one, quite a hassle.
Some scenarios really need directory-level hashing, but no convenient CLI tool exists.

x hashdir recursively calculates hashes of all files in a directory, produces a unified hash list.

```bash
x hashdir --md5 /path/to/dir
x hashdir --sha256 /path/to/dir
x hashdir --sha1 ./project > project.sha1
```

Very convenient for verifying project integrity or detecting file changes.

### [tee](https://x-cmd.com/mod/tee)

- Added `tee` module documentation —— because wanting both log output AND command success status is really hard.

In CI scripts, you often want to save output to a log file AND check if the command succeeded.
Use a pipe? Exit code is tee, not the original command. Don't use a pipe? No tee effect.
`set -o pipefail` is rather obscure, and not all shells support it.

x tee uses named pipe technology to give you both - log output AND original exit code preserved.

```bash
x tee output.txt -- make build
x tee results.txt -- pytest tests/
x tee deploy.log -- ./deploy.sh
```

No more dancing around exit codes in CI scripts.

最后提交信息为： Updating main branch using x7 release -> a31a30ccdcfd11c6fd9a6b6e74...

v0.8.5

a31a30c

2026-03-05 22:15

v0.8.5

[👉 View X-CMD blog for more information about this version](https://x-cmd.com/blog/260306)
[👉 Version compare: v0.8.4...v0.8.5](https://gitee.com/x-cmd/x-cmd/compare/v0.8.4...v0.8.5)

## ✅ Upgrade Guide

```bash 
x upgrade 
```

## 📃 Changelog

![x-cmd-v085](https://codeberg.org/x-cmd/img/raw/branch/main/assets/x-cmd-v085.cn.webp)

### [humantime](https://x-cmd.com/mod/humantime)

- Added `humantime` module documentation —— provides underlying support for time parameter conversion.

Humans say "wait 3 hours", machines only understand "10800 seconds". humantime bridges this GAP.
It's the infrastructure behind commands like `x sleep 3h` and `x timeout 2h30m`, enabling natural time expressions.

```bash
x humantime 3600      # outputs 1h
x humantime 2h30m     # outputs 9000
```

Supports d/h/m/s, decimal seconds too. No more mental math for cron jobs.

### [is](https://x-cmd.com/mod/is)

- Added `is` module documentation —— because `[ ]` syntax always makes me nervous when writing scripts.

Especially checking number ranges, file ages, environment types —— I always mix up the test command syntax.
So I wrapped them into subcommands with clearer semantics.

```bash
x is int 42                 # is it an integer?
x is minmax 1 100 50        # is 50 within 1-100?
x is interactive            # is this an interactive shell?
```

Supports type checks, range checks, file comparisons, environment detection. Code reads more self-explanatory.

### [assert](https://x-cmd.com/mod/assert)

- Added `assert` module documentation —— because a debugging session broke me.

A function secretly modified `$HOME`, causing all subsequent commands to fail. Took me forever to find.
So I built this testing tool, focusing on variable snapshots: save → execute → compare, leaks become obvious.

```bash
x assert true [ 1 -eq 1 ]
x assert var save; my_func; x assert var cmp
```

Also supports standard true/false, type checks, file assertions. Handy for writing module tests.

### [host](https://x-cmd.com/mod/host)

- Added `host` module documentation —— because editing `/etc/hosts` always felt dangerous to me.

sudo vim, one typo and DNS breaks. Plus finding domains means scanning with your eyes.
Made a safer version with fuzzy search, auto backup, and easy recovery.

```bash
x host              # paged view with search
x host fz           # fuzzy find domains
x host ed myapp.local=192.168.1.100
```

Auto backup before editing, operations done in temp files, only writes after confirmation. Much safer.

### [tmp](https://x-cmd.com/mod/tmp)

- Added `tmp` module documentation —— because cross-platform temp directories are a mess.

Linux is `/tmp`, macOS might be `$TMPDIR`, Windows is different. Scripts always need to check.
Unified and wrapped them, plus added temp file/directory creation.

```bash
x tmp path          # get system temp directory
x tmp mkdir cache   # create temp directory
x tmp mkfile        # create temp file
```

Versions with `_` suffix (like `x tmp path_`) are internal, results stored in variables for other scripts.

### [rand](https://x-cmd.com/mod/rand)

- Added `rand` module documentation —— because `$RANDOM` isn't enough when writing test data.

Need UUIDs, fake emails, random IPs? Always had to look up other tools.
Just bundled them together, with batch generation too.

```bash
x rand uuid
x rand uuidv7       # time-ordered UUID
x rand email 5      # batch generate 5 emails
x rand int 1 100    # random int between 1-100
```

Also supports floats, various string formats. Less hassle when writing test cases.

### [str](https://x-cmd.com/mod/str)

- Added `str` module documentation —— because I always mix up the awk/sed/tr combo.

Case conversion, base64, trim, replace —— these simple operations are actually quite common.
But having to think "which tool this time" is annoying. One command handles them all.

```bash
x str upper hello
x str base64 hello
x str trim "  spaced  "
```

Also supports split/join, md5/sha256, line ending conversion. Covers most daily string processing needs.

### [gemini](https://x-cmd.com/mod/gemini)

- Fixed custom endpoint configuration not taking effect —— sorry, this was a dumb mistake.

A user reported that after configuring a proxy endpoint, requests were still going to Google's official API.
Turned out to be a logic issue in config loading —— custom endpoint wasn't being applied to requests properly.

Now it works as expected:
```bash
x gemini --cfg endpoint=https://your-proxy.example.com
```

Thanks to @shlroland for reporting this in #376.

最后提交信息为： Updating main branch using x7 release -> 21153a96e2d6a02ddabdde4c9e...

v0.8.4

21153a9

2026-03-01 16:29

v0.8.4

[👉 Version compare: v0.8.3...v0.8.4](https://gitee.com/x-cmd/x-cmd/compare/v0.8.3...v0.8.4)

## 📃 Changelog

### [mac](https://x-cmd.com/mod/mac)

- 🛡️ x mac sb: Security Shield for the AI Agent Era

When your AI assistant helps you manipulate files, are you really comfortable letting it run wild?
x mac sb is a macOS sandbox tool built by x-cmd, designed specifically for AI Agents — letting you enjoy the efficiency boost from AI while precisely controlling its permission boundaries.

It can:
- Restrict AI to only access specified directories
- Block access to sensitive areas (like ~/.ssh, ~/.bitcoin)
- Disable dangerous operations like network and clipboard
- Support security policies from level 0-9

Example:
```bash
x mac sb -9 -d "$HOME/.bitcoin" -d "$HOME/.ssh" -d "$HOME/Library" claude
```

---
Easter Egg: The Afternoon When ~ Got the Better of Me

Recently fixed an interesting little bug:
`~` gets expanded by the shell before case matching, so `~/*` becomes `/Users/xxx/*`, causing paths starting with `~` to be missed during security checks and bypassing the permission validation
Caught it early though, fixed it with a single quote 😊

### [abox](https://x-cmd.com/mod/abox)

- Added `abox` module —— a Docker sandbox for OpenClaw, Claude Code and other AI coding agents.

Worried about these AIs messing around on your local machine? abox spins up an isolated container — let them do whatever inside, can't cause real damage.

What it does right now:
- `x abox start` launches in seconds, common ports auto-mapped
- `x abox cmdi bash` opens an interactive shell to run your AI tools
- SSH key login, no password hassle

Just started using it myself, seems okay so far. If you want to try:
```bash
x abox start
x abox cmdi bash
```

Fresh out of the oven, bugs expected. Let me know if something breaks.

### [tui](https://x-cmd.com/mod/tui)

- Improved `x tui form` interaction experience.

This is the component x-cmd uses internally for config wizards — those setup forms you fill out when initializing modules.

Now it just flows better:
- Edit mode and selection mode don't fight with each other anymore
- Tab or Enter cycles through form fields, no more guessing which key to press
- Arrow keys handle selection, left/right just moves the cursor, no interference

Less of that "wait, what state am I in?" confusion from before.

最后提交信息为： Updating main branch using x7 release -> da28dcad94cd66ffdb51e6e645...

v0.8.3

da28dca

2026-02-16 21:16

v0.8.3

[👉 View X-CMD blog for more information about this version](https://x-cmd.com/blog/260217)
[👉 Version compare: v0.8.2...v0.8.3](https://gitee.com/x-cmd/x-cmd/compare/v0.8.2...v0.8.3)

## ✅ Upgrade Guide

```bash 
x upgrade 
```

## 📃 Changelog

### [x-cmd](https://x-cmd.com/mod/x-cmd)

- 🎉 Hey X-CMD friends, Happy Year of the Horse! 🐴 🎊 x-cmd CLI keeps getting smoother, vibe coding keeps getting better.

New year, new vibes — starting from v0.8.3, we're releasing X-CMD under Apache 2.0 license. Enterprise users can now use and integrate x-cmd more freely.

Happy coding ~ 🐮🍺

### [minimax](https://x-cmd.com/mod/minimax)

- minimax module default model upgraded to Minimax-M2.5.

During Chinese New Year, kimi, glm-5, and minimax all released their latest models. minimax was nice enough to upgrade without raising prices, and we've been trying out M2.5.

Example:
```bash
x minimax --cfg
```

### [claude](https://x-cmd.com/mod/claude)

- claude module adds `x claude use` command.

If you only use one provider, setting it as default lets you just run `claude` directly — simpler than `x claude mm`.

For project-level config, use `-p` (short for `--project`), affecting only the current project:
- `x claude use glm` → writes to ~/.claude/settings.json (global)
- `x claude use -p mm` → writes to .claude/settings.local.json (project, overrides global)

Want to switch back? `x claude use claude`. We also kept the prefix mode:
- `x claude mm` uses minimax
- `x claude glm` uses Zhipu glm-5

Examples:
```bash
# Global default to Zhipu
x claude use glm

# Project-level to minimax (overrides global)
x claude use -p mm

# Switch back to official Claude
x claude use claude

# Prefix mode
x claude mm hello
x claude glm hello
```

最后提交信息为： Updating main branch using x7 release -> 636b979bebac9f2550b2608354...

v0.8.2

3ddb4bc

2026-02-12 23:14

v0.8.2

[👉 Version compare: v0.8.1...v0.8.2](https://gitee.com/x-cmd/x-cmd/compare/v0.8.1...v0.8.2)

## 📃 Changelog

### [nanorc](https://x-cmd.com/mod/nanorc)

- Added `nanorc` module —— honestly, I got burned first.

Spent ages debugging my nanorc config on macOS, only to discover the system's "nano" is actually pico in disguise — it doesn't support nanorc at all.
Googled it, and yeah, turns out pico's the culprit.

I've used scopatz/nanorc on Raspberry Pi two years ago. 126 syntax files, hasn't been updated in six years, but rock solid.
Brought it over this time — resource pack downloads via curl, friendly for Linux and embedded environments.
Hosted on codeberg for faster access in China.

There's also `x nano` which auto-detects and downloads GNU nano for direct use, leaving the system untouched.

Examples:
```bash
# Download and configure syntax highlighting
x nanorc setup

# List installed syntax files
x nanorc ls

# Clean up configuration
x nanorc tdown
```

### [claude](https://x-cmd.com/mod/claude)

- Added `-g|--global` option to `x claude attr` —— purely because we have too many projects and I'm too lazy to config them one by one.

Previously `use`, `set`, `rm`, and `cat` only modified project-level configs. With many x-cmd projects, that gets annoying.
Added `-g` for global scope, problem solved.

Examples:
```bash
# Set configuration globally
x claude attr use -g

# Display global config
x claude attr cat -g

# Remove global config
x claude attr rm -g
```

### [zhipu](https://x-cmd.com/mod/zhipu)

- Added `glm-5` model support to `zhipu` —— 50% price hike means they're pretty confident.

If they dare raise the price, they must believe in the model. So I integrated it into my workflow right away.

Honestly haven't used it enough to have a strong opinion yet. Just getting it ready first.

Example:
```bash
# Use glm-5 as default model
x zhipu --cfg model=glm-5
```

最后提交信息为： Updating main branch using x7 release -> 86f91de8f1a1aa1f594ef960ab...

v0.8.1

86f91de

2026-02-11 22:32

v0.8.1

[👉 View X-CMD blog for more information about this version](https://x-cmd.com/blog/260211)
[👉 Version compare: v0.8.0...v0.8.1](https://gitee.com/x-cmd/x-cmd/compare/v0.8.0...v0.8.1)

## 📃 Changelog

### [mthreads](https://x-cmd.com/mod/mthreads)

- Added `mthreads` module —— came for the 30-day free trial, ended up buying a package.

Moore Threads runs GLM 4.7 on domestic GPUs, wanted to see how it goes.
But we shipped a bit rushed — some requests return 502, not production-ready yet.
Talking to their support engineers. Fingers crossed.

If you want to tinker:
```bash
# Interactive API key setup
x mthreads init

# Launch Claude Code, try Moore Threads backend
x claude mt
```

### [minimax](https://x-cmd.com/mod/minimax)

- Added `minimax` module —— users asked for it, I'm already using it.

MiniMax has solid response times and decent features for the domestic market.
It's my main backend now. Threw in a `cpstatus` command to check code plan usage — they bill on a 5-hour window.

```bash
# Interactive setup
x minimax init

# Check current usage (5-hour window)
x minimax cpstatus

# Launch Claude Code with MiniMax
x claude mm
```

If you've got MiniMax credits, give it a spin.

### [claude](https://x-cmd.com/mod/claude)

- Added `mt` and `mm` subcommands —— purely because I'm lazy.

Switching backends manually was annoying. Env vars, API keys, model params... can't remember all that.
Now `x claude mm` jumps straight to MiniMax, `x claude mt` for Moore Threads.
Configs are reused from `x mthreads init` and `x minimax init`.

I'm mostly on MiniMax these days, but good to have options.
```bash
# MiniMax, one shot
x claude mm

# Moore Threads, same thing
x claude mt
```

### [nu](https://x-cmd.com/mod/nu)

- Fixed Nushell 0.110.0 compatibility.

Nushell majors always ship breaking changes — we're used to it by now.
This time they changed $nu.home-path to $nu.home-dir.
@Cattle0Horse mentioned it in the WeChat group, we filed the issue right away.

Thanks for the heads-up, @Cattle0Horse!
See: https://github.com/x-cmd/x-cmd/issues/371

最后提交信息为： Updating main branch using x7 release -> 5279a2d7e2e9454481ba11fad8...

GVPx-cmd/x-cmd

搜索帮助

GVP x-cmd/x-cmd