Multi-Client

# Start a long-running deploy on the laptop via CLI
# On laptop (CLI)
await client.terminal.set_machine("prod-server")
await client.terminal.execute("./deploy.sh")
# Deploy starts...
 
# Close laptop (detach, but session continues on agent)
 
# On phone (mobile app)
# Attach to same session from a different device
# See deploy progress
# Can send input if needed

# Human attaches as operator with full control
human_stream = client.terminal.stream()
await human_stream.attach(session_id)
 
# AI attaches as observer — can read output but cannot send input
ai_stream = client.terminal.stream(mode="observer")
await ai_stream.attach(session_id)
 
# AI callback: analyze each output chunk and send suggestions
async def on_output(data):
    analysis = await ai.analyze(data)
    if analysis.has_suggestion:
        send_notification(analysis.suggestion)
 
ai_stream.on_output(on_output)
 
# Human works normally; AI suggests improvements via notifications

# Send a command and get back a unique ID for tracking
command_id = await stream.send_command("ls -la")
 
# Wait for output tagged with the matching command ID
output = await stream.wait_for_command(command_id)

from cmdop import AsyncCMDOPClient
 
async with AsyncCMDOPClient.remote(api_key="cmd_xxx") as client:
    # Look up the active session for a machine by hostname
    session = await client.terminal.get_active_session("my-server")
 
    # Open a bidirectional stream (defaults to operator mode)
    stream = client.terminal.stream()
    # Print decoded output as it arrives in real-time
    stream.on_output(lambda data: print(data.decode(), end=""))
 
    # Attach to the session and send a command
    await stream.attach(session.session_id)
    await stream.send_input(b"ls -la\n")

# Attach in observer mode — read-only, cannot send input
stream = client.terminal.stream(mode="observer")
stream.on_output(lambda data: print(data.decode(), end=""))
 
await stream.attach(session.session_id)
# Sending input in observer mode will raise an error

# Retrieve session metadata including the list of all attached clients
session = await client.terminal.get_session(session_id)
print(f"Attached clients: {session.attached_clients}")
# [
#   {"user": "[email protected]", "mode": "operator", "client": "cli"},
#   {"user": "[email protected]", "mode": "observer", "client": "web"},
# ]

# Alice and Bob are both in "acme-corp" workspace
# Both can attach to any session in that workspace
 
# Alice finds the active session for "server"
session = await alice_client.terminal.get_active_session("server")
 
# Bob can also attach — same workspace grants access
await bob_client.terminal.attach(session.session_id)

# Workspace roles determine the maximum access level for sessions
 
# Owner/Admin: Can attach to any session as operator
# Member: Can attach to any session as operator
# Guest: Can only attach as observer (if configured)

# If you only need to watch, use observer mode to prevent accidental input
stream = client.terminal.stream(mode="observer")

# Check if another operator is already attached before taking over
session = await client.terminal.get_session(session_id)
if session.has_active_operator:
    # Notify the team before attaching as a second operator
    notify_team(f"Taking over session on {session.machine}")

# AI observer for automated monitoring and alerting
ai_stream = client.terminal.stream(mode="observer")
ai_stream.on_output(detect_errors_and_alert)

# Enable session recording for audit and review
session = await client.terminal.get_active_session(
    "server",
    record=True  # Enable recording
)