463 lines
16 KiB
Python
463 lines
16 KiB
Python
"""Slash command handler for direct bot control."""
|
||
|
||
from __future__ import annotations
|
||
|
||
import argparse
|
||
import json
|
||
import logging
|
||
import re
|
||
import uuid
|
||
from typing import Optional, Tuple
|
||
|
||
from agent.manager import manager
|
||
from agent.scheduler import scheduler
|
||
from agent.task_runner import task_runner
|
||
from agent.cc_runner import VALID_PERMISSION_MODES, DEFAULT_PERMISSION_MODE
|
||
from orchestrator.agent import agent
|
||
from orchestrator.tools import set_current_user, get_current_chat
|
||
|
||
logger = logging.getLogger(__name__)
|
||
|
||
# Permission mode aliases (user-facing shorthand → internal CC mode)
|
||
_PERM_ALIASES: dict[str, str] = {
|
||
"bypass": "bypassPermissions",
|
||
"skip": "bypassPermissions",
|
||
"accept": "acceptEdits",
|
||
"plan": "plan",
|
||
}
|
||
_PERM_LABELS: dict[str, str] = {
|
||
"bypassPermissions": "bypass",
|
||
"acceptEdits": "accept",
|
||
"plan": "plan",
|
||
}
|
||
|
||
|
||
def _resolve_perm(alias: str) -> str | None:
|
||
"""Map user-facing alias to internal permission mode, or None if invalid."""
|
||
return _PERM_ALIASES.get(alias.lower().strip())
|
||
|
||
|
||
def _perm_label(mode: str) -> str:
|
||
"""Return short human-readable label for a permission mode."""
|
||
return _PERM_LABELS.get(mode, mode)
|
||
|
||
|
||
def parse_command(text: str) -> Optional[Tuple[str, str]]:
|
||
"""
|
||
Parse a bot command from text.
|
||
Returns (command, args) or None if not a command.
|
||
Commands must start with COMMAND_PREFIX (default "//").
|
||
"""
|
||
from config import COMMAND_PREFIX
|
||
text = text.strip()
|
||
if not text.startswith(COMMAND_PREFIX):
|
||
return None
|
||
# Strip the prefix, then split into command word and args
|
||
body = text[len(COMMAND_PREFIX):]
|
||
parts = body.split(None, 1)
|
||
cmd = COMMAND_PREFIX + parts[0].lower()
|
||
args = parts[1] if len(parts) > 1 else ""
|
||
return (cmd, args)
|
||
|
||
|
||
async def handle_command(user_id: str, text: str) -> Optional[str]:
|
||
"""
|
||
Handle a slash command. Returns the reply or None if not a command.
|
||
"""
|
||
parsed = parse_command(text)
|
||
if not parsed:
|
||
return None
|
||
|
||
cmd, args = parsed
|
||
logger.info("Command: %s args=%r user=...%s", cmd, args[:50], user_id[-8:])
|
||
|
||
# In ROUTER_MODE, only handle router-specific commands locally.
|
||
# Session commands (//status, //new, //close, etc.) fall through to node forwarding.
|
||
from config import ROUTER_MODE, COMMAND_PREFIX
|
||
P = COMMAND_PREFIX
|
||
if ROUTER_MODE and cmd not in (P+"nodes", P+"node", P+"help", P+"h", P+"?"):
|
||
return None
|
||
|
||
set_current_user(user_id)
|
||
|
||
if cmd in (P+"new", P+"n"):
|
||
return await _cmd_new(user_id, args)
|
||
elif cmd in (P+"status", P+"list", P+"ls", P+"l"):
|
||
return await _cmd_status(user_id)
|
||
elif cmd in (P+"close", P+"c"):
|
||
return await _cmd_close(user_id, args)
|
||
elif cmd in (P+"switch", P+"s"):
|
||
return await _cmd_switch(user_id, args)
|
||
elif cmd == P+"retry":
|
||
return await _cmd_retry(user_id)
|
||
elif cmd in (P+"help", P+"h", P+"?"):
|
||
return _cmd_help()
|
||
elif cmd == P+"direct":
|
||
return _cmd_direct(user_id)
|
||
elif cmd == P+"smart":
|
||
return _cmd_smart(user_id)
|
||
elif cmd == P+"tasks":
|
||
return _cmd_tasks()
|
||
elif cmd == P+"shell":
|
||
return await _cmd_shell(args)
|
||
elif cmd == P+"remind":
|
||
return await _cmd_remind(args)
|
||
elif cmd == P+"perm":
|
||
return await _cmd_perm(user_id, args)
|
||
elif cmd in (P+"nodes", P+"node"):
|
||
return await _cmd_nodes(user_id, args)
|
||
else:
|
||
return None
|
||
|
||
|
||
async def _cmd_new(user_id: str, args: str) -> str:
|
||
"""Create a new session."""
|
||
if not args:
|
||
return "Usage: /new <project_dir> [initial_message] [--timeout N] [--perm MODE]\nModes: bypass (default), accept, plan"
|
||
|
||
parser = argparse.ArgumentParser()
|
||
parser.add_argument("working_dir", nargs="?", help="Project directory")
|
||
parser.add_argument("rest", nargs="*", help="Initial message")
|
||
parser.add_argument("--timeout", type=int, default=None, help="CC timeout in seconds")
|
||
parser.add_argument("--idle", type=int, default=None, help="Idle timeout in seconds")
|
||
parser.add_argument("--perm", default=None, help="Permission mode: bypass, accept, plan")
|
||
|
||
try:
|
||
parsed = parser.parse_args(args.split())
|
||
except SystemExit:
|
||
return "Usage: /new <project_dir> [initial_message] [--timeout N] [--idle N] [--perm MODE]"
|
||
|
||
if not parsed.working_dir:
|
||
return "Error: project_dir is required"
|
||
|
||
permission_mode = _resolve_perm(parsed.perm) if parsed.perm else DEFAULT_PERMISSION_MODE
|
||
if permission_mode is None:
|
||
return f"Invalid --perm. Valid modes: bypass, accept, plan"
|
||
|
||
working_dir = parsed.working_dir
|
||
initial_msg = " ".join(parsed.rest) if parsed.rest else None
|
||
|
||
from orchestrator.tools import _resolve_dir
|
||
|
||
try:
|
||
resolved = _resolve_dir(working_dir)
|
||
except ValueError as e:
|
||
return f"Error: {e}"
|
||
|
||
import uuid as _uuid
|
||
conv_id = str(_uuid.uuid4())[:8]
|
||
await manager.create(
|
||
conv_id,
|
||
str(resolved),
|
||
owner_id=user_id,
|
||
idle_timeout=parsed.idle or 1800,
|
||
cc_timeout=float(parsed.timeout or 300),
|
||
permission_mode=permission_mode,
|
||
)
|
||
agent._active_conv[user_id] = conv_id
|
||
|
||
response = None
|
||
if initial_msg:
|
||
response = await manager.send(conv_id, initial_msg, user_id=user_id)
|
||
|
||
chat_id = get_current_chat()
|
||
if chat_id:
|
||
from bot.feishu import send_card, send_text, build_sessions_card
|
||
sessions = manager.list_sessions(user_id=user_id)
|
||
routing_mode = "Direct 🟢" if agent.get_passthrough(user_id) else "Smart ⚪"
|
||
card = build_sessions_card(sessions, conv_id, routing_mode)
|
||
await send_card(chat_id, "chat_id", card)
|
||
if initial_msg and response:
|
||
await send_text(chat_id, "chat_id", response)
|
||
return ""
|
||
|
||
perm_label = _perm_label(permission_mode)
|
||
reply = f"✓ Created session `{conv_id}` in `{resolved}` [{perm_label}]"
|
||
if parsed.timeout:
|
||
reply += f" (timeout: {parsed.timeout}s)"
|
||
if initial_msg and response:
|
||
reply += f"\n\n{response}"
|
||
return reply
|
||
|
||
|
||
async def _cmd_status(user_id: str) -> str:
|
||
"""Show status: sessions and current mode."""
|
||
sessions = manager.list_sessions(user_id=user_id)
|
||
active = agent.get_active_conv(user_id)
|
||
passthrough = agent.get_passthrough(user_id)
|
||
mode = "Direct 🟢" if passthrough else "Smart ⚪"
|
||
|
||
chat_id = get_current_chat()
|
||
if chat_id:
|
||
from bot.feishu import send_card, build_sessions_card
|
||
card = build_sessions_card(sessions, active, mode)
|
||
await send_card(chat_id, "chat_id", card)
|
||
return ""
|
||
|
||
if not sessions:
|
||
return "No active sessions."
|
||
lines = ["**Your Sessions:**\n"]
|
||
for i, s in enumerate(sessions, 1):
|
||
marker = "→ " if s["conv_id"] == active else " "
|
||
perm = _perm_label(s.get("permission_mode", DEFAULT_PERMISSION_MODE))
|
||
lines.append(f"{marker}{i}. `{s['conv_id']}` - `{s['cwd']}` [{perm}]")
|
||
lines.append(f"\n**Mode:** {mode}")
|
||
lines.append("Use `//switch <n>` to activate a session.")
|
||
lines.append("Use `//direct` or `//smart` to change mode.")
|
||
return "\n".join(lines)
|
||
|
||
|
||
async def _cmd_close(user_id: str, args: str) -> str:
|
||
"""Close a session."""
|
||
# If a specific conv_id is given by name (not a number), resolve it directly.
|
||
if args:
|
||
try:
|
||
int(args)
|
||
by_number = True
|
||
except ValueError:
|
||
by_number = False
|
||
|
||
if not by_number:
|
||
# Explicit conv_id given — look it up directly (may belong to another user).
|
||
conv_id = args.strip()
|
||
try:
|
||
success = await manager.close(conv_id, user_id=user_id)
|
||
if success:
|
||
if agent.get_active_conv(user_id) == conv_id:
|
||
agent._active_conv[user_id] = None
|
||
return f"✓ Closed session `{conv_id}`"
|
||
else:
|
||
return f"Session `{conv_id}` not found."
|
||
except PermissionError as e:
|
||
return str(e)
|
||
|
||
sessions = manager.list_sessions(user_id=user_id)
|
||
if not sessions:
|
||
return "No sessions to close."
|
||
|
||
if args:
|
||
try:
|
||
idx = int(args) - 1
|
||
if 0 <= idx < len(sessions):
|
||
conv_id = sessions[idx]["conv_id"]
|
||
else:
|
||
return f"Invalid session number. Use 1-{len(sessions)}."
|
||
except ValueError:
|
||
conv_id = args.strip()
|
||
else:
|
||
conv_id = agent.get_active_conv(user_id)
|
||
if not conv_id:
|
||
return "No active session. Use `//close <conv_id>` or `//close <n>`."
|
||
|
||
try:
|
||
success = await manager.close(conv_id, user_id=user_id)
|
||
if success:
|
||
if agent.get_active_conv(user_id) == conv_id:
|
||
agent._active_conv[user_id] = None
|
||
return f"✓ Closed session `{conv_id}`"
|
||
else:
|
||
return f"Session `{conv_id}` not found."
|
||
except PermissionError as e:
|
||
return str(e)
|
||
|
||
|
||
async def _cmd_switch(user_id: str, args: str) -> str:
|
||
"""Switch to a different session."""
|
||
sessions = manager.list_sessions(user_id=user_id)
|
||
if not sessions:
|
||
return "No sessions available."
|
||
|
||
if not args:
|
||
return "Usage: /switch <n>\n" + await _cmd_status(user_id)
|
||
|
||
try:
|
||
idx = int(args) - 1
|
||
if 0 <= idx < len(sessions):
|
||
conv_id = sessions[idx]["conv_id"]
|
||
agent._active_conv[user_id] = conv_id
|
||
return f"✓ Switched to session `{conv_id}` ({sessions[idx]['cwd']})"
|
||
else:
|
||
return f"Invalid session number. Use 1-{len(sessions)}."
|
||
except ValueError:
|
||
return f"Invalid number: {args}"
|
||
|
||
|
||
async def _cmd_perm(user_id: str, args: str) -> str:
|
||
"""Change the permission mode of the active (or specified) session."""
|
||
parts = args.split()
|
||
if not parts:
|
||
return (
|
||
"Usage: /perm <mode> [conv_id]\n"
|
||
"Modes: bypass (default), accept, plan\n"
|
||
" bypass — skip all permission checks\n"
|
||
" accept — auto-accept file edits, confirm shell commands\n"
|
||
" plan — plan only, no writes"
|
||
)
|
||
|
||
alias = parts[0]
|
||
conv_id = parts[1] if len(parts) > 1 else agent.get_active_conv(user_id)
|
||
|
||
permission_mode = _resolve_perm(alias)
|
||
if permission_mode is None:
|
||
return f"Unknown mode '{alias}'. Valid: bypass, accept, plan"
|
||
|
||
if not conv_id:
|
||
return "No active session. Use `//perm <mode> <conv_id>` or activate a session first."
|
||
|
||
try:
|
||
manager.set_permission_mode(conv_id, permission_mode, user_id=user_id)
|
||
except KeyError:
|
||
return f"Session `{conv_id}` not found."
|
||
except PermissionError as e:
|
||
return str(e)
|
||
|
||
return f"✓ Session `{conv_id}` permission mode set to **{_perm_label(permission_mode)}**"
|
||
|
||
|
||
async def _cmd_retry(user_id: str) -> str:
|
||
"""Retry the last message (placeholder - needs history tracking)."""
|
||
return "Retry not yet implemented. Just send your message again."
|
||
|
||
|
||
def _cmd_direct(user_id: str) -> str:
|
||
"""Enable direct mode - messages go straight to Claude Code."""
|
||
conv = agent.get_active_conv(user_id)
|
||
if not conv:
|
||
return "No active session. Use `//new` or `//switch` first."
|
||
agent.set_passthrough(user_id, True)
|
||
return f"✓ Direct mode ON. Messages go directly to session `{conv}`."
|
||
|
||
|
||
def _cmd_smart(user_id: str) -> str:
|
||
"""Enable smart mode - messages go through LLM for routing."""
|
||
agent.set_passthrough(user_id, False)
|
||
return "✓ Smart mode ON. Messages go through LLM for intelligent routing."
|
||
|
||
|
||
def _cmd_tasks() -> str:
|
||
"""List background tasks."""
|
||
tasks = task_runner.list_tasks()
|
||
if not tasks:
|
||
return "No background tasks."
|
||
|
||
lines = ["**Background Tasks:**\n"]
|
||
for t in tasks:
|
||
status_emoji = {"completed": "✅", "failed": "❌", "running": "⏳", "pending": "⏸️"}.get(
|
||
t["status"], "❓"
|
||
)
|
||
lines.append(f"{status_emoji} #{t['task_id']} - {t['description'][:50]} ({t['elapsed']}s)")
|
||
return "\n".join(lines)
|
||
|
||
|
||
async def _cmd_shell(args: str) -> str:
|
||
"""Execute a shell command directly."""
|
||
if not args:
|
||
return "Usage: /shell <command>\nExample: /shell git status"
|
||
|
||
from orchestrator.tools import ShellTool, get_current_chat
|
||
|
||
tool = ShellTool()
|
||
result = await tool._arun(command=args)
|
||
try:
|
||
data = json.loads(result)
|
||
if "error" in data:
|
||
return f"❌ {data['error']}"
|
||
output = []
|
||
if data.get("stdout"):
|
||
output.append(data["stdout"])
|
||
if data.get("stderr"):
|
||
output.append(f"[stderr] {data['stderr']}")
|
||
output.append(f"[exit code: {data.get('exit_code', '?')}]")
|
||
return "\n".join(output) if output else "(no output)"
|
||
except json.JSONDecodeError:
|
||
return result
|
||
|
||
|
||
async def _cmd_remind(args: str) -> str:
|
||
"""Set a reminder."""
|
||
if not args:
|
||
return "Usage: /remind <time> <message>\nExample: /remind 10m check the build\nTime format: 30s, 10m, 1h"
|
||
|
||
parts = args.split(None, 1)
|
||
if len(parts) < 2:
|
||
return "Usage: /remind <time> <message>\nExample: /remind 10m check the build"
|
||
|
||
time_str, message = parts
|
||
match = re.match(r'^(\d+)(s|m|h)$', time_str.lower())
|
||
if not match:
|
||
return "Invalid time format. Use: 30s, 10m, 1h"
|
||
|
||
value = int(match.group(1))
|
||
unit = match.group(2)
|
||
seconds = value * {'s': 1, 'm': 60, 'h': 3600}[unit]
|
||
|
||
chat_id = get_current_chat()
|
||
job_id = await scheduler.schedule_once(
|
||
delay_seconds=seconds,
|
||
message=message,
|
||
notify_chat_id=chat_id,
|
||
)
|
||
|
||
return f"⏰ Reminder #{job_id} set for {value}{unit} from now"
|
||
|
||
|
||
async def _cmd_nodes(user_id: str, args: str) -> str:
|
||
"""List nodes or switch active node."""
|
||
from config import ROUTER_MODE
|
||
if not ROUTER_MODE:
|
||
return "Not in router mode. Run standalone.py for multi-host support."
|
||
|
||
from router.nodes import get_node_registry
|
||
registry = get_node_registry()
|
||
|
||
if args:
|
||
args = args.strip()
|
||
if registry.set_active_node(user_id, args):
|
||
return f"✓ Active node set to: {args}"
|
||
return f"Error: Node '{args}' not found"
|
||
|
||
nodes = registry.list_nodes()
|
||
if not nodes:
|
||
return "No nodes connected."
|
||
|
||
active_node_id = None
|
||
active_node = registry.get_active_node(user_id)
|
||
if active_node:
|
||
active_node_id = active_node.node_id
|
||
|
||
lines = ["**Connected Nodes:**\n"]
|
||
for n in nodes:
|
||
marker = "→ " if n["node_id"] == active_node_id else " "
|
||
status = "🟢" if n["status"] == "online" else "🔴"
|
||
lines.append(f"{marker}{n['display_name']} {status} sessions={n['sessions']}")
|
||
lines.append("\nUse `//node <name>` to switch active node.")
|
||
return "\n".join(lines)
|
||
|
||
|
||
def _cmd_help() -> str:
|
||
"""Show help."""
|
||
from config import COMMAND_PREFIX as P
|
||
return f"""**Commands:** (prefix: `{P}`)
|
||
{P}new <dir> [msg] [--timeout N] [--idle N] [--perm MODE] - Create session
|
||
{P}status - Show sessions and current mode
|
||
{P}close [n] - Close session (active or by number)
|
||
{P}switch <n> - Switch to session by number
|
||
{P}perm <mode> [conv_id] - Set permission mode (bypass/accept/plan)
|
||
{P}direct - Direct mode: messages → Claude Code (no LLM overhead)
|
||
{P}smart - Smart mode: messages → LLM routing (default)
|
||
{P}shell <cmd> - Run shell command (bypasses LLM)
|
||
{P}remind <time> <msg> - Set reminder (e.g. {P}remind 10m check build)
|
||
{P}tasks - List background tasks
|
||
{P}nodes - List connected host nodes
|
||
{P}node <name> - Switch active node
|
||
{P}retry - Retry last message
|
||
{P}help - Show this help
|
||
|
||
**Permission modes** (used by {P}perm and {P}new --perm):
|
||
bypass — 跳过所有权限确认，CC 自动执行一切操作（默认）
|
||
适合：受信任的沙盒环境、自动化任务
|
||
accept — 自动接受文件编辑，但 shell 命令仍需手动确认
|
||
适合：日常开发，需要对命令执行保持控制
|
||
plan — 只规划、不执行任何写操作
|
||
适合：先预览 CC 的操作计划再决定是否执行"""
|