396 lines
13 KiB
Python
396 lines
13 KiB
Python
import asyncio
|
||
import logging
|
||
import shlex
|
||
import signal
|
||
import sys
|
||
from uuid import uuid4
|
||
|
||
from yuxi.channel.context import ChannelContext
|
||
from yuxi.channel.message.models import MessageType, PeerInfo, PeerKind, UnifiedMessage
|
||
|
||
logger = logging.getLogger(__name__)
|
||
|
||
RICH_AVAILABLE = False
|
||
_rich_console = None
|
||
_RICH_THEMES: dict = {}
|
||
|
||
try:
|
||
from rich.console import Console
|
||
from rich.markdown import Markdown
|
||
from rich.theme import Theme
|
||
|
||
_RICH_THEMES = {
|
||
"dark": None,
|
||
"light": Theme(
|
||
{
|
||
"markdown.code": "bright_black on white",
|
||
"markdown.heading": "bold blue",
|
||
}
|
||
),
|
||
"no-color": Theme(inherit=False),
|
||
}
|
||
|
||
def _init_rich_console(theme: str = "dark") -> None:
|
||
global _rich_console, RICH_AVAILABLE
|
||
try:
|
||
_rich_console = Console(theme=_RICH_THEMES.get(theme))
|
||
RICH_AVAILABLE = True
|
||
except Exception:
|
||
_rich_console = None
|
||
RICH_AVAILABLE = False
|
||
|
||
_init_rich_console("dark")
|
||
except ImportError:
|
||
pass
|
||
|
||
PROMPT_TOOLKIT_AVAILABLE = False
|
||
_prompt_session = None
|
||
_kb = None
|
||
try:
|
||
from prompt_toolkit import PromptSession
|
||
from prompt_toolkit.completion import Completer, Completion
|
||
from prompt_toolkit.history import InMemoryHistory
|
||
from prompt_toolkit.key_binding import KeyBindings
|
||
|
||
class _TerminalCompleter(Completer):
|
||
_COMMANDS = ["help", "exit", "quit", "clear", "history", "model"]
|
||
|
||
def get_completions(self, document, complete_event):
|
||
text = document.text_before_cursor.strip()
|
||
if text.startswith("/"):
|
||
word = text[1:].split()[0] if len(text) > 1 else ""
|
||
for cmd in self._COMMANDS:
|
||
if cmd.startswith(word):
|
||
yield Completion(
|
||
f"/{cmd}",
|
||
start_position=-len(text),
|
||
display_meta=f"/{cmd}",
|
||
)
|
||
|
||
_kb = KeyBindings()
|
||
|
||
@_kb.add("escape", "enter")
|
||
def _multiline_send(event):
|
||
event.current_buffer.validate_and_handle()
|
||
|
||
try:
|
||
_prompt_session = PromptSession(
|
||
history=InMemoryHistory(),
|
||
completer=_TerminalCompleter(),
|
||
)
|
||
PROMPT_TOOLKIT_AVAILABLE = True
|
||
except Exception:
|
||
logger.debug("prompt_toolkit PromptSession unavailable (no console), falling back to readline")
|
||
except ImportError:
|
||
pass
|
||
|
||
|
||
class TerminalAdapter:
|
||
def __init__(self):
|
||
self._msg_counter = 0
|
||
self._ctx: ChannelContext | None = None
|
||
self._original_sigint = None
|
||
self._typing_task: asyncio.Task | None = None
|
||
self._is_typing = False
|
||
self._history: list[str] = []
|
||
self._commands = {
|
||
"help": self._cmd_help,
|
||
"exit": self._cmd_exit,
|
||
"quit": self._cmd_exit,
|
||
"clear": self._cmd_clear,
|
||
"history": self._cmd_history,
|
||
"model": self._cmd_model,
|
||
}
|
||
|
||
def list_account_ids(self, config: dict) -> list[str]:
|
||
return ["default"]
|
||
|
||
async def resolve_account(self, account_id: str) -> dict:
|
||
return {
|
||
"account_id": "default",
|
||
"enabled": True,
|
||
"configured": True,
|
||
"name": "Terminal",
|
||
}
|
||
|
||
def is_configured(self, account: dict) -> bool:
|
||
return True
|
||
|
||
def is_enabled(self, account: dict) -> bool:
|
||
return True
|
||
|
||
async def start(self, ctx: ChannelContext) -> None:
|
||
logger.info("Terminal channel starting (stdin listener)")
|
||
self._ctx = ctx
|
||
|
||
if RICH_AVAILABLE:
|
||
account_config = ctx.config.get("accounts", {}).get("default", {})
|
||
theme = account_config.get("color_theme", "dark")
|
||
_init_rich_console(theme)
|
||
|
||
self._print_greeting()
|
||
|
||
def _sigint_handler(_signum, _frame):
|
||
sys.stdout.write("\n\n[中断请求，正在取消当前回复...]\n")
|
||
sys.stdout.flush()
|
||
ctx.cancel_event.set()
|
||
|
||
self._original_sigint = signal.signal(signal.SIGINT, _sigint_handler)
|
||
|
||
try:
|
||
while not ctx.cancel_event.is_set():
|
||
try:
|
||
line = await self._read_stdin_line()
|
||
except EOFError:
|
||
logger.info("Terminal stdin closed (EOF)")
|
||
sys.stdout.write("\nGoodbye!\n")
|
||
sys.stdout.flush()
|
||
break
|
||
|
||
if line is None:
|
||
break
|
||
|
||
text = line.strip()
|
||
if not text:
|
||
if PROMPT_TOOLKIT_AVAILABLE:
|
||
continue
|
||
self._print_prompt()
|
||
continue
|
||
|
||
if text.startswith("/") and self._handle_command(text):
|
||
if not PROMPT_TOOLKIT_AVAILABLE:
|
||
self._print_prompt()
|
||
continue
|
||
|
||
if text.startswith('"""'):
|
||
text = await self._read_multiline_input(text)
|
||
if text is None or not text.strip():
|
||
if not PROMPT_TOOLKIT_AVAILABLE:
|
||
self._print_prompt()
|
||
continue
|
||
|
||
self._enqueue_message(text)
|
||
|
||
finally:
|
||
if self._original_sigint is not None:
|
||
signal.signal(signal.SIGINT, self._original_sigint)
|
||
self._original_sigint = None
|
||
|
||
async def stop(self, ctx: ChannelContext) -> None:
|
||
logger.info("Terminal channel stopping")
|
||
ctx.cancel_event.set()
|
||
if self._original_sigint is not None:
|
||
signal.signal(signal.SIGINT, self._original_sigint)
|
||
self._original_sigint = None
|
||
await self.clear_typing("terminal-default")
|
||
sys.stdout.write("\n")
|
||
sys.stdout.flush()
|
||
|
||
async def send_text(self, target_id: str, content: str) -> None:
|
||
sys.stdout.write("\n")
|
||
if RICH_AVAILABLE:
|
||
_rich_console.print(Markdown(content))
|
||
else:
|
||
sys.stdout.write(content)
|
||
sys.stdout.write("\n")
|
||
sys.stdout.flush()
|
||
if not PROMPT_TOOLKIT_AVAILABLE:
|
||
self._print_prompt()
|
||
|
||
async def send_typing(self, target_id: str, thread_id: str | None = None) -> None:
|
||
if not sys.stdin.isatty():
|
||
return
|
||
self._is_typing = True
|
||
self._typing_task = asyncio.create_task(self._typing_animation())
|
||
|
||
async def clear_typing(self, target_id: str, thread_id: str | None = None) -> None:
|
||
self._is_typing = False
|
||
if self._typing_task and not self._typing_task.done():
|
||
self._typing_task.cancel()
|
||
try:
|
||
await self._typing_task
|
||
except asyncio.CancelledError:
|
||
pass
|
||
self._typing_task = None
|
||
sys.stdout.write("\r\033[K")
|
||
sys.stdout.flush()
|
||
|
||
def _enqueue_message(self, text: str) -> None:
|
||
self._history.append(text)
|
||
if len(self._history) > 100:
|
||
self._history.pop(0)
|
||
self._msg_counter += 1
|
||
msg_id = f"term:{uuid4().hex[:12]}"
|
||
|
||
msg = UnifiedMessage(
|
||
msg_id=msg_id,
|
||
channel_type="terminal",
|
||
account_id="default",
|
||
content=text,
|
||
message_type=MessageType.TEXT,
|
||
sender=PeerInfo(
|
||
kind=PeerKind.DIRECT,
|
||
id="terminal-user",
|
||
display_name="Dev",
|
||
),
|
||
timestamp=None,
|
||
)
|
||
|
||
asyncio.create_task(self._put_message(msg))
|
||
|
||
async def _put_message(self, msg: UnifiedMessage) -> None:
|
||
if self._ctx is None:
|
||
return
|
||
if self._ctx.queue.qsize() >= self._ctx.queue.maxsize * 0.8:
|
||
self._print_warning("消息队列繁忙，请稍候...")
|
||
await self._ctx.queue.put(msg)
|
||
|
||
def _handle_command(self, text: str) -> bool:
|
||
try:
|
||
parts = shlex.split(text)
|
||
except ValueError:
|
||
return False
|
||
if not parts or not parts[0].startswith("/"):
|
||
return False
|
||
|
||
cmd_name = parts[0][1:].lower()
|
||
handler = self._commands.get(cmd_name)
|
||
if handler and self._ctx:
|
||
handler(self._ctx)
|
||
return True
|
||
return False
|
||
|
||
@staticmethod
|
||
def _cmd_help(ctx: ChannelContext) -> None:
|
||
help_text = (
|
||
"\n可用命令:\n"
|
||
" /help 显示此帮助信息\n"
|
||
" /exit, /quit 退出 Terminal 渠道\n"
|
||
" /clear 清屏\n"
|
||
" /history 显示输入历史\n"
|
||
" /model <name> 切换模型\n"
|
||
"\n快捷键: Ctrl+C 中断回复 Ctrl+D 退出\n"
|
||
)
|
||
sys.stdout.write(f"{help_text}\n")
|
||
sys.stdout.flush()
|
||
|
||
@staticmethod
|
||
def _cmd_exit(ctx: ChannelContext) -> None:
|
||
sys.stdout.write("\nGoodbye!\n")
|
||
sys.stdout.flush()
|
||
ctx.cancel_event.set()
|
||
|
||
@staticmethod
|
||
def _cmd_clear(ctx: ChannelContext) -> None:
|
||
sys.stdout.write("\033[2J\033[H")
|
||
sys.stdout.flush()
|
||
|
||
@staticmethod
|
||
def _cmd_model(ctx: ChannelContext) -> None:
|
||
sys.stdout.write("\n模型切换请在系统中配置\n")
|
||
sys.stdout.flush()
|
||
|
||
def _cmd_history(self, ctx: ChannelContext) -> None:
|
||
if not self._history:
|
||
sys.stdout.write("\n暂无历史记录\n")
|
||
sys.stdout.flush()
|
||
return
|
||
lines = ["\n历史记录:"]
|
||
for i, entry in enumerate(self._history, 1):
|
||
preview = entry[:60] + "..." if len(entry) > 60 else entry
|
||
lines.append(f" {i}. {preview}")
|
||
lines.append("")
|
||
sys.stdout.write("\n".join(lines) + "\n")
|
||
sys.stdout.flush()
|
||
|
||
async def _read_stdin_line(self, multiline: bool = False) -> str | None:
|
||
loop = asyncio.get_event_loop()
|
||
|
||
if PROMPT_TOOLKIT_AVAILABLE:
|
||
try:
|
||
line = await loop.run_in_executor(
|
||
None,
|
||
lambda: _prompt_session.prompt(
|
||
"... " if multiline else "> ",
|
||
multiline=multiline,
|
||
key_bindings=_kb if multiline else None,
|
||
),
|
||
)
|
||
return line
|
||
except EOFError:
|
||
raise
|
||
except KeyboardInterrupt:
|
||
return ""
|
||
|
||
line = await loop.run_in_executor(None, sys.stdin.readline)
|
||
if not line:
|
||
return None
|
||
return line
|
||
|
||
async def _read_multiline_input(self, first_line: str) -> str | None:
|
||
remaining = first_line[3:]
|
||
|
||
if PROMPT_TOOLKIT_AVAILABLE:
|
||
try:
|
||
loop = asyncio.get_event_loop()
|
||
return await loop.run_in_executor(
|
||
None,
|
||
lambda: _prompt_session.prompt(
|
||
"... ",
|
||
multiline=True,
|
||
key_bindings=_kb,
|
||
default=remaining,
|
||
),
|
||
)
|
||
except (KeyboardInterrupt, EOFError):
|
||
return None
|
||
|
||
lines = []
|
||
if remaining.strip():
|
||
lines.append(remaining.strip())
|
||
while self._ctx and not self._ctx.cancel_event.is_set():
|
||
sys.stdout.write("... ")
|
||
sys.stdout.flush()
|
||
try:
|
||
next_line = await self._read_stdin_line()
|
||
except EOFError:
|
||
break
|
||
if next_line is None:
|
||
break
|
||
stripped = next_line.strip()
|
||
if stripped == '"""':
|
||
break
|
||
lines.append(next_line.rstrip("\n"))
|
||
return "\n".join(lines) if lines else None
|
||
|
||
async def _typing_animation(self) -> None:
|
||
frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
|
||
idx = 0
|
||
while self._is_typing:
|
||
frame = frames[idx % len(frames)]
|
||
if RICH_AVAILABLE:
|
||
sys.stdout.write(f"\r[bold yellow]{frame}[/bold yellow] 思考中...")
|
||
else:
|
||
sys.stdout.write(f"\r{frame} 思考中...")
|
||
sys.stdout.flush()
|
||
idx += 1
|
||
await asyncio.sleep(0.1)
|
||
|
||
@staticmethod
|
||
def _print_greeting() -> None:
|
||
sys.stdout.write("Terminal 渠道已启动，输入问题与 Agent 对话")
|
||
sys.stdout.write("\n按 Ctrl+C 中断回复，Ctrl+D 退出\n")
|
||
if not PROMPT_TOOLKIT_AVAILABLE:
|
||
sys.stdout.write("\n> ")
|
||
sys.stdout.flush()
|
||
|
||
@staticmethod
|
||
def _print_prompt() -> None:
|
||
sys.stdout.write("> ")
|
||
sys.stdout.flush()
|
||
|
||
@staticmethod
|
||
def _print_warning(text: str) -> None:
|
||
sys.stdout.write(f"\n[{text}]\n")
|
||
sys.stdout.flush()
|