#终端集成示例

import asyncio
import websockets
import json

class AsyncTerminalClient:
    def __init__(self, base_url="ws://localhost:8080"):
        self.base_url = base_url
        self.websocket = None
        self.session_id = None

    async def connect(self, session_id=None):
        ws_url = f"{self.base_url}/v1/shell/ws"
        if session_id:
            ws_url += f"?session_id={session_id}"

        self.websocket = await websockets.connect(ws_url)
        print("已连接到终端")

        # 启动消息处理器
        asyncio.create_task(self.handle_messages())

    async def handle_messages(self):
        try:
            async for message in self.websocket:
                data = json.loads(message)
                await self.process_message(data)
        except websockets.exceptions.ConnectionClosed:
            print("终端连接已关闭")
        except Exception as e:
            print(f"处理消息时出错：{e}")

    async def process_message(self, message):
        msg_type = message.get('type')
        data = message.get('data')

        if msg_type == 'session_id':
            self.session_id = data
            print(f"会话 ID：{data}")
        elif msg_type == 'output':
            print(data, end='')
        elif msg_type == 'ready':
            print(f"终端就绪：{data}")
        elif msg_type == 'ping':
            await self.send_pong(data)
        elif msg_type == 'error':
            print(f"服务器错误：{data}")

    async def send_command(self, command):
        if self.websocket:
            await self.websocket.send(json.dumps({
                'type': 'input',
                'data': command + '\n'
            }))

    async def send_pong(self, timestamp):
        if self.websocket:
            await self.websocket.send(json.dumps({
                'type': 'pong',
                'timestamp': timestamp
            }))

    async def resize_terminal(self, cols, rows):
        if self.websocket:
            await self.websocket.send(json.dumps({
                'type': 'resize',
                'data': {'cols': cols, 'rows': rows}
            }))

    async def disconnect(self):
        if self.websocket:
            await self.websocket.close()

# 使用示例
async def main():
    client = AsyncTerminalClient()
    await client.connect()

    # 等待连接建立
    await asyncio.sleep(1)

    # 发送一些命令
    await client.send_command('ls -la')
    await client.send_command('whoami')
    await client.send_command('python3 --version')

    # 保持活动以接收输出
    await asyncio.sleep(5)

    await client.disconnect()

# 运行示例
asyncio.run(main())

import asyncio
import websockets
import json
from typing import Dict, Optional

class MultiSessionTerminal:
    def __init__(self, base_url="ws://localhost:8080"):
        self.base_url = base_url
        self.sessions: Dict[str, websockets.WebSocketServerProtocol] = {}
        self.session_outputs: Dict[str, str] = {}

    async def create_session(self, session_name: str) -> str:
        """创建新的终端会话"""
        ws_url = f"{self.base_url}/v1/shell/ws"
        websocket = await websockets.connect(ws_url)

        # 等待会话 ID
        session_id = None
        async for message in websocket:
            data = json.loads(message)
            if data.get('type') == 'session_id':
                session_id = data.get('data')
                break

        if session_id:
            self.sessions[session_name] = websocket
            self.session_outputs[session_name] = ""

            # 为此会话启动消息处理器
            asyncio.create_task(self.handle_session_messages(session_name))

            return session_id
        else:
            raise Exception("获取会话 ID 失败")

    async def connect_to_session(self, session_name: str, session_id: str):
        """连接到现有会话"""
        ws_url = f"{self.base_url}/v1/shell/ws?session_id={session_id}"
        websocket = await websockets.connect(ws_url)

        self.sessions[session_name] = websocket
        if session_name not in self.session_outputs:
            self.session_outputs[session_name] = ""

        asyncio.create_task(self.handle_session_messages(session_name))

    async def handle_session_messages(self, session_name: str):
        """处理特定会话的消息"""
        websocket = self.sessions[session_name]

        try:
            async for message in websocket:
                data = json.loads(message)
                await self.process_session_message(session_name, data)
        except websockets.exceptions.ConnectionClosed:
            print(f"会话 {session_name} 连接已关闭")
            if session_name in self.sessions:
                del self.sessions[session_name]

    async def process_session_message(self, session_name: str, message):
        msg_type = message.get('type')
        data = message.get('data')

        if msg_type == 'output':
            self.session_outputs[session_name] += data
            print(f"[{session_name}] {data}", end='')
        elif msg_type == 'ready':
            print(f"[{session_name}] 终端就绪：{data}")
        elif msg_type == 'ping':
            await self.send_pong(session_name, data)

    async def send_command(self, session_name: str, command: str):
        """向特定会话发送命令"""
        if session_name in self.sessions:
            websocket = self.sessions[session_name]
            await websocket.send(json.dumps({
                'type': 'input',
                'data': command + '\n'
            }))
        else:
            raise Exception(f"会话 {session_name} 未找到")

    async def send_pong(self, session_name: str, timestamp):
        if session_name in self.sessions:
            websocket = self.sessions[session_name]
            await websocket.send(json.dumps({
                'type': 'pong',
                'timestamp': timestamp
            }))

    async def get_session_output(self, session_name: str) -> str:
        """获取会话的累积输出"""
        return self.session_outputs.get(session_name, "")

    async def close_session(self, session_name: str):
        """关闭特定会话"""
        if session_name in self.sessions:
            await self.sessions[session_name].close()
            del self.sessions[session_name]
            if session_name in self.session_outputs:
                del self.session_outputs[session_name]

    async def close_all_sessions(self):
        """关闭所有会话"""
        for session_name in list(self.sessions.keys()):
            await self.close_session(session_name)

# 使用示例
async def multi_session_demo():
    terminal = MultiSessionTerminal()

    # 创建多个会话
    session1_id = await terminal.create_session("build")
    session2_id = await terminal.create_session("test")
    session3_id = await terminal.create_session("dev")

    print(f"创建的会话：build={session1_id}, test={session2_id}, dev={session3_id}")

    # 等待会话准备就绪
    await asyncio.sleep(2)

    # 并行运行不同的命令
    await asyncio.gather(
        terminal.send_command("build", "npm run build"),
        terminal.send_command("test", "npm test"),
        terminal.send_command("dev", "npm run dev")
    )

    # 让命令运行
    await asyncio.sleep(10)

    # 获取输出
    build_output = await terminal.get_session_output("build")
    test_output = await terminal.get_session_output("test")

    print("构建输出长度：", len(build_output))
    print("测试输出长度：", len(test_output))

    # 清理
    await terminal.close_all_sessions()

asyncio.run(multi_session_demo())