#示例

from aio_sandbox import AioClient
import asyncio

# 初始化客户端
client = AioClient(
    base_url="http://localhost:8080",  # AIO Sandbox URL
    timeout=30.0,  # 请求超时（秒）
    retries=3,     # 重试次数
    retry_delay=1.0  # 重试之间的延迟
)

async def shell_example():
    # 执行简单命令
    result = await client.shell.exec(command="ls -la")

    if result.success:
        print(f"输出：{result.data.output}")
        print(f"退出码：{result.data.exit_code}")

    # 使用会话管理执行
    session_id = "my-session-1"
    await client.shell.exec(
        command="cd /workspace && pwd",
        session_id=session_id
    )

    # 在同一会话中继续
    result = await client.shell.exec(
        command="ls",
        session_id=session_id
    )

    # 长时间运行任务的异步执行
    await client.shell.exec(
        command="python long_script.py",
        async_mode=True,
        session_id=session_id
    )

    # 查看会话输出
    view_result = await client.shell.view(session_id=session_id)
    print(view_result.data.output)

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

async def file_example():
    # 写入文件
    await client.file.write(
        file="/tmp/example.py",
        content="""
import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 10, 100)
y = np.sin(x)

plt.plot(x, y)
plt.savefig('/tmp/plot.png')
print("图表已保存！")
        """.strip()
    )

    # 读取文件内容
    content = await client.file.read(file="/tmp/example.py")
    if content.success:
        print(f"文件内容：\n{content.data.content}")

    # 列出目录内容
    files = await client.file.list(
        path="/tmp",
        recursive=True,
        include_size=True
    )

    for file_info in files.data.files:
        print(f"{file_info.name}: {file_info.size} 字节")

    # 在文件中搜索
    search_result = await client.file.search(
        file="/tmp/example.py",
        regex=r"import \w+"
    )

    if search_result.success:
        for match in search_result.data.matches:
            print(f"第 {match.line} 行：{match.content}")

    # 按模式查找文件
    found_files = await client.file.find(
        path="/tmp",
        glob="*.py"
    )

asyncio.run(file_example())

async def code_execution_example():
    # 在 Jupyter 内核中执行 Python 代码
    jupyter_result = await client.jupyter.execute(
        code="""
import pandas as pd
import numpy as np

# 创建示例数据
df = pd.DataFrame({
    'x': np.random.randn(100),
    'y': np.random.randn(100)
})

print(f"DataFrame 形状：{df.shape}")
print(df.head())
        """,
        timeout=60,
        session_id="data-analysis-session"
    )

    if jupyter_result.success:
        print("Jupyter 输出：")
        for output in jupyter_result.data.outputs:
            if output.output_type == "stream":
                print(output.text)
            elif output.output_type == "execute_result":
                print(output.data.get("text/plain", ""))

    # 执行 Node.js 代码
    nodejs_result = await client.nodejs.execute(
        code="""
const fs = require('fs');
const path = require('path');

// 如果存在则读取 package.json
try {
    const packagePath = path.join(process.cwd(), 'package.json');
    if (fs.existsSync(packagePath)) {
        const pkg = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
        console.log(`项目：${pkg.name || '未知'}`);
        console.log(`版本：${pkg.version || '未知'}`);
    } else {
        console.log('未找到 package.json');
    }
} catch (error) {
    console.error('错误：', error.message);
}
        """,
        timeout=30
    )

    if nodejs_result.success:
        print(f"Node.js 输出：{nodejs_result.data.stdout}")

asyncio.run(code_execution_example())

async def mcp_example():
    # 列出可用的 MCP 服务器
    servers = await client.mcp.list_servers()
    print("可用的 MCP 服务器：", servers.data)

    # 从特定服务器获取工具
    browser_tools = await client.mcp.list_tools(server_name="browser")

    for tool in browser_tools.data.tools:
        print(f"工具：{tool.name}")
        print(f"描述：{tool.description}")

    # 执行工具
    screenshot_result = await client.mcp.execute_tool(
        server_name="browser",
        tool_name="screenshot",
        arguments={
            "url": "https://example.com",
            "width": 1920,
            "height": 1080
        }
    )

    if screenshot_result.success:
        # 保存截图数据
        await client.file.write(
            file="/tmp/screenshot.png",
            content=screenshot_result.data.content[0].data,  # Base64 图像数据
            append=False
        )

asyncio.run(mcp_example())

async def robust_example():
    try:
        # 始终使用上下文管理器进行资源清理
        async with AioClient("http://localhost:8080") as client:
            # 设置错误处理
            result = await client.shell.exec("potentially-failing-command")

            if not result.success:
                print(f"命令失败：{result.message}")
                if hasattr(result, 'error_code'):
                    print(f"错误代码：{result.error_code}")

            # 检查沙盒状态
            status = await client.sandbox.get_context()
            print(f"沙盒运行时间：{status.data.uptime}")
            print(f"可用包：{len(status.data.packages)}")

    except Exception as e:
        print(f"连接错误：{e}")

asyncio.run(robust_example())