cmux/docs-site/content/docs/socket-api.mdx
Lawrence Chen 9817d131f8
Release v1.23.0 (#31)
* Rename cmuxterm to cmux across entire codebase

- Rename GitHub repos: manaflow-ai/cmuxterm -> manaflow-ai/cmux,
  manaflow-ai/homebrew-cmuxterm -> manaflow-ai/homebrew-cmux
- Rename bundle IDs: com.cmuxterm.app -> com.cmux.app
- Rename CLI: CLI/cmuxterm.swift -> CLI/cmux.swift
- Rename homebrew submodule: homebrew-cmuxterm -> homebrew-cmux
- Update all socket paths: /tmp/cmuxterm*.sock -> /tmp/cmux*.sock
- Update all GitHub URLs, DMG names, Sparkle URLs
- Update all source files, scripts, tests, docs, CI workflows

* Bump version to 1.23.0
2026-02-09 15:30:43 -08:00

263 lines
4 KiB
Text

---
title: Socket API
description: Unix socket API for programmatic control of cmux
---
# Socket API
cmux exposes a Unix socket for programmatic control, enabling automation and integration with tools like Claude Code.
## Socket Location
| Build | Socket Path |
|-------|-------------|
| Release | `/tmp/cmux.sock` |
| Debug | `/tmp/cmux-debug.sock` |
You can override the path with the `CMUX_SOCKET_PATH` environment variable.
## Access Modes
cmux has three access modes, configurable in Settings:
| Mode | Description |
|------|-------------|
| **Off** | Socket disabled |
| **Notifications only** | Only notification commands allowed |
| **Full control** | All commands enabled |
<Callout type="warn">
On shared machines, use "Notifications only" mode to prevent other users from controlling your terminals.
</Callout>
## Protocol
Commands are sent as newline-terminated JSON:
```json
{"command": "command-name", "arg1": "value1"}
```
Responses are newline-terminated JSON:
```json
{"success": true, "data": {...}}
{"success": false, "error": "Error message"}
```
## Commands Reference
### Tab Management
#### list-tabs
List all open tabs.
```json
{"command": "list-tabs"}
```
Response:
```json
{
"success": true,
"tabs": [
{"id": "uuid", "title": "Tab 1", "directory": "/Users/..."}
]
}
```
#### new-tab
Create a new tab.
```json
{"command": "new-tab"}
```
#### select-tab
Switch to a specific tab.
```json
{"command": "select-tab", "id": "tab-uuid"}
```
#### current-tab
Get the currently active tab.
```json
{"command": "current-tab"}
```
#### close-tab
Close a specific tab.
```json
{"command": "close-tab", "id": "tab-uuid"}
```
### Split Management
#### new-split
Create a new split pane.
```json
{"command": "new-split", "direction": "right"}
```
Direction options: `left`, `right`, `up`, `down`
#### list-panels
List all panes in the current tab.
```json
{"command": "list-panels"}
```
#### focus-panel
Focus a specific pane.
```json
{"command": "focus-panel", "id": "panel-uuid"}
```
### Input Control
#### send
Send text input to a terminal.
```json
{"command": "send", "text": "echo hello\n"}
```
#### send-key
Send a key press.
```json
{"command": "send-key", "key": "enter"}
```
Key options: `enter`, `tab`, `escape`, `backspace`, `delete`, `up`, `down`, `left`, `right`
#### send-panel
Send text to a specific panel.
```json
{"command": "send-panel", "id": "panel-uuid", "text": "ls -la\n"}
```
#### send-key-panel
Send a key press to a specific panel.
```json
{"command": "send-key-panel", "id": "panel-uuid", "key": "enter"}
```
### Notifications
#### notify
Send a notification.
```json
{
"command": "notify",
"title": "Build Complete",
"subtitle": "Project X",
"body": "Build finished successfully"
}
```
#### list-notifications
List all notifications.
```json
{"command": "list-notifications"}
```
#### clear-notifications
Clear all notifications.
```json
{"command": "clear-notifications"}
```
### App Control
#### ping
Check if the socket is responsive.
```json
{"command": "ping"}
```
Response:
```json
{"success": true, "pong": true}
```
#### set-app-focus
Simulate app focus/unfocus (for testing).
```json
{"command": "set-app-focus", "focused": true}
```
## Example: Python Client
```python
import socket
import json
def send_command(cmd):
sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
sock.connect('/tmp/cmux.sock')
sock.send(json.dumps(cmd).encode() + b'\n')
response = sock.recv(4096).decode()
sock.close()
return json.loads(response)
# List tabs
tabs = send_command({"command": "list-tabs"})
print(tabs)
# Send notification
send_command({
"command": "notify",
"title": "Hello",
"body": "From Python!"
})
```
## Example: Shell Script
```bash
#!/bin/bash
# Function to send commands
cmux_cmd() {
echo "$1" | nc -U /tmp/cmux.sock
}
# List tabs
cmux_cmd '{"command": "list-tabs"}'
# Send notification
cmux_cmd '{"command": "notify", "title": "Done", "body": "Task complete"}'
```