diff --git a/.gitignore b/.gitignore index bae64bc6c..5622689bf 100644 --- a/.gitignore +++ b/.gitignore @@ -32,3 +32,4 @@ _agents/ # Internal docs docs/ .agents/rules/deploy.md +.qwen/ diff --git a/.qwen/settings.json b/.qwen/settings.json new file mode 100644 index 000000000..82f43b86d --- /dev/null +++ b/.qwen/settings.json @@ -0,0 +1,23 @@ +{ + "permissions": { + "allow": [ + "Bash(psql *)", + "Bash(docker-compose *)", + "Bash(docker ps *)", + "Bash(ls *)", + "Bash(tail *)", + "Bash(lsof *)", + "Bash(curl *)", + "Bash(python3 *)", + "Bash(docker network *)", + "Bash(docker *)", + "Bash(sleep *)", + "Bash(find *)", + "Bash(xargs *)", + "Bash(lark-cli *)", + "Bash(npm run *)", + "Bash(sed *)" + ] + }, + "$version": 3 +} \ No newline at end of file diff --git a/.qwen/settings.json.orig b/.qwen/settings.json.orig new file mode 100644 index 000000000..7981cafc5 --- /dev/null +++ b/.qwen/settings.json.orig @@ -0,0 +1,7 @@ +{ + "permissions": { + "allow": [ + "Bash(psql *)" + ] + } +} \ No newline at end of file diff --git a/PR_DESCRIPTION.md b/PR_DESCRIPTION.md new file mode 100644 index 000000000..033172bb4 --- /dev/null +++ b/PR_DESCRIPTION.md @@ -0,0 +1,103 @@ +# Multi-User Workspace Isolation System + +## 🎯 Summary + +Implements comprehensive multi-user workspace isolation for Clawith, solving session pollution when multiple users interact with the same agent. Includes Feishu integration, file sharing tools, and session management. + +## ✨ Key Features + +### 1. User Workspace Isolation +- Each user gets their own `users/{uuid}/files/` directory +- Platform user ID (UUID) instead of Feishu open_id (ou_xxx) +- Agent-level `user_isolation_enabled` toggle +- Personal Space tab in UI for managing private files + +### 2. File Sharing +- `workspace/xxx` - User-isolated files (default) +- `shared/xxx` - Shared across all users +- `enterprise_info/xxx` - Company-wide info +- `move_file()` and `copy_file()` tools + +### 3. Feishu Integration +- `/new` or `新建对话` command to create new session +- Session cached in Redis for 24 hours +- Files uploaded to correct user directory + +## 🛠️ New Tools + +```python +# Move file to shared space +move_file("workspace/report.md", "shared/report.md") + +# Copy file for sharing +copy_file("workspace/notes.md", "shared/notes.md") + +# List files (shows workspace/ prefix) +list_files("") +# Returns: 📂 workspace/: 0 folder(s), 1 file(s) +# 📄 workspace/file.xlsx (96.8KB) + +# Send file via channel +send_channel_file( + file_path="workspace/file.xlsx", + member_name="Recipient Name", + message="Optional message" +) +``` + +## 🐛 Bug Fixes + +- Fix Feishu file upload path (UUID vs open_id) +- Fix `send_channel_file` path resolution in user workspace +- Fix `list_files` to show `workspace/` prefix +- Fix `user_workspaces API` to list `files/` directory +- Fix vision injection in LLM caller + +## 📦 Migration + +⚠️ **Breaking Change**: User workspace paths changed from `users/{open_id}/` to `users/{uuid}/` + +Run migration script: +```bash +python3 migrate_user_workspaces.py +``` + +## 📁 Files Changed (27 files) + +### Backend +- `backend/app/models/agent.py` - Add user_isolation_enabled field +- `backend/app/schemas/schemas.py` - Update schemas +- `backend/app/api/agents.py` - Support updating isolation setting +- `backend/app/api/feishu.py` - File upload, /new command, session caching +- `backend/app/api/user_workspaces.py` - New API for user workspace management +- `backend/app/services/agent_tools.py` - File tools, path resolution +- `backend/app/services/agent_context.py` - User-specific memory loading +- `backend/app/services/channel_user_service.py` - Fix multi-provider issue +- `backend/app/services/llm/caller.py` - Vision injection fix +- `backend/alembic/versions/add_user_isolation.py` - DB migration + +### Frontend +- `frontend/src/components/UserWorkspace.tsx` - Personal Space component +- `frontend/src/services/userWorkspaceApi.ts` - API client +- `frontend/src/pages/AgentCreate.tsx` - Isolation toggle +- `frontend/src/pages/AgentDetail.tsx` - Personal Space tab +- `frontend/src/i18n/en.json` & `zh.json` - Translations + +### Scripts +- `migrate_user_workspaces.py` - Migration script +- `create_agent.py` - CLI agent creation tool + +## 🧪 Testing + +1. Upload file via Feishu +2. Verify file saved to `users/{uuid}/files/` +3. Use `list_files('')` - should show `workspace/filename` +4. Use `send_channel_file` - should successfully send +5. Use `/new` command - should create new session +6. Verify subsequent messages use new session + +## 📊 Stats + +- 27 files changed +- 2,359 insertions(+) +- 52 deletions(-) diff --git a/USER_ISOLATION_COMPLETE.md b/USER_ISOLATION_COMPLETE.md new file mode 100644 index 000000000..4ca3bf9d8 --- /dev/null +++ b/USER_ISOLATION_COMPLETE.md @@ -0,0 +1,202 @@ +# 多用户 Workspace 隔离 - 完整实施总结 + +## ✅ 已完成的修改 + +### 1. 数据库修改 + +**添加列到 agents 表**: +```sql +ALTER TABLE agents ADD COLUMN user_isolation_enabled BOOLEAN DEFAULT true NOT NULL; +``` + +### 2. 模型层修改 + +**`backend/app/models/agent.py`**: +```python +# === USER ISOLATION: Enable user-specific workspace === +user_isolation_enabled: Mapped[bool] = mapped_column(Boolean, default=True, nullable=False, + comment='Enable user-specific workspace isolation for multi-user scenarios') +``` + +### 3. Schema 层修改 + +**`backend/app/schemas/schemas.py`**: +- `AgentCreate`: 添加 `user_isolation_enabled: bool = True` +- `AgentOut`: 添加 `user_isolation_enabled: bool = True` +- `AgentUpdate`: 添加 `user_isolation_enabled: bool | None = None` + +### 4. API 层修改 + +**`backend/app/api/agents.py`**: +- 创建 agent 时支持设置 `user_isolation_enabled` +- 更新 agent 时支持修改 `user_isolation_enabled` + +### 5. 服务层修改 + +**`backend/app/services/agent_tools.py`**: + +- `ensure_workspace()` - 添加用户隔离逻辑： + ```python + if user_id: + # Check if user isolation is enabled + user_isolation_enabled = agent.user_isolation_enabled + + if user_isolation_enabled: + user_ws = ws / "users" / str(user_id) + # Create user directories... + return user_ws + ``` + +- `execute_tool()` - 传递 `user_id` 获取用户 workspace： + ```python + ws = await ensure_workspace(agent_id, tenant_id=_agent_tenant_id, user_id=user_id) + ``` + +- `_write_file()` - 重定向用户文件到用户目录： + ```python + elif rel_path.startswith("workspace/") and user_id: + user_root = (ws / "users" / str(user_id)).resolve() + file_path = (user_root / sub).resolve() + ``` + +## 📁 目录结构 + +``` +/data/agents/{agent_id}/ +├── skills/ # 共享技能目录 +├── memory/ # 共享记忆目录 +├── soul.md # 共享人格定义 +├── workspace/ # 共享工作区 +├── tasks.json # 共享任务 +└── users/ # 用户隔离目录（仅当启用隔离时） + ├── {user_id_1}/ # 用户 1 的独立空间 + │ ├── files/ # 用户上传的文件 + │ ├── sessions/ # 用户会话数据 + │ └── memory.md # 用户个人记忆 + └── {user_id_2}/ # 用户 2 的独立空间 +``` + +## 🎛️ 配置方式 + +### 1. 创建 Agent 时设置 + +```bash +curl -X POST http://localhost:8000/api/agents/ \ + -H "Authorization: Bearer YOUR_TOKEN" \ + -H "Content-Type: application/json" \ + -d '{ + "name": "客服助手", + "role_description": "专业的客服机器人", + "user_isolation_enabled": true + }' +``` + +### 2. 更新现有 Agent + +```bash +curl -X PUT http://localhost:8000/api/agents/{agent_id} \ + -H "Authorization: Bearer YOUR_TOKEN" \ + -H "Content-Type: application/json" \ + -d '{ + "user_isolation_enabled": true + }' +``` + +### 3. 在 Clawith 界面设置 + +在 Agent 设置页面添加开关： +- ☑️ 启用多用户隔离（Enable Multi-User Isolation） +- 说明：启用后，每个用户将有独立的 workspace，文件和个人记忆不会共享 + +## 🔄 工作流程 + +### 飞书消息处理流程 + +1. **用户发送消息** → 飞书 bot +2. **feishu.py 接收消息**: + - 获取 `user_id`（飞书用户 ID） + - 调用 `resolve_channel_user` 解析用户 +3. **调用 LLM**: + - `call_llm()` → `execute_tool()` + - 传入 `user_id` +4. **工具执行**: + - `ensure_workspace(agent_id, user_id)` + - 检查 `user_isolation_enabled` + - 如果启用 → 返回用户 workspace + - 如果禁用 → 返回共享 workspace +5. **文件保存**: + - 用户文件保存到 `/data/agents/{agent_id}/users/{user_id}/files/` + +### 隔离效果 + +**启用隔离后**: +- ✅ 用户 A 上传的文件，用户 B 不可见 +- ✅ 用户 A 的个人记忆，用户 B 不可见 +- ✅ 用户 A 的会话历史，用户 B 不可见 +- ✅ 共享技能、soul.md、共享记忆仍然共享 + +**禁用隔离（默认行为）**: +- 所有用户共享同一个 workspace +- 保持原有行为，向后兼容 + +## 🧪 测试方法 + +### 测试步骤 + +1. **创建测试 Agent**: + ```bash + curl -X POST http://localhost:8000/api/agents/ \ + -H "Authorization: Bearer TOKEN" \ + -d '{"name": "测试 Agent", "user_isolation_enabled": true}' + ``` + +2. **用户 A 上传文件**: + - 在飞书中给 agent 发送消息并上传文件 + - 文件保存到：`/data/agents/{agent_id}/users/{user_a_id}/files/` + +3. **用户 B 查看文件**: + - 用户 B 的 workspace：`/data/agents/{agent_id}/users/{user_b_id}/files/`（空目录） + - 用户 B 看不到用户 A 的文件 + +4. **验证共享资源**: + - 两个用户都可以访问 `skills/` 和 `soul.md` + +### 测试脚本 + +```python +import asyncio +import uuid +from app.services.agent_tools import ensure_workspace + +async def test(): + agent_id = uuid.UUID('...') + user_a = uuid.uuid4() + user_b = uuid.uuid4() + + # 创建用户 workspace + ws_a = await ensure_workspace(agent_id, user_id=user_a) + ws_b = await ensure_workspace(agent_id, user_id=user_b) + + # 验证隔离 + assert ws_a != ws_b + assert (ws_a / 'files').exists() + assert (ws_b / 'files').exists() + + print('✅ 用户隔离测试通过！') + +asyncio.run(test()) +``` + +## ⚠️ 注意事项 + +1. **向后兼容**: 默认启用 (`user_isolation_enabled=True`)，新 agent 自动使用隔离 +2. **现有 Agent**: 现有 agent 默认值为 `True`，可以通过 API 关闭 +3. **性能影响**: 每次工具执行需要额外查询 agent 配置 +4. **迁移脚本**: 可选 - 为现有 agent 创建用户目录 + +## 📝 后续优化 + +1. **前端界面**: 在 Agent 设置页面添加开关 +2. **迁移工具**: 将现有用户文件移动到用户目录 +3. **性能优化**: 缓存 agent 的 `user_isolation_enabled` 状态 +4. **权限检查**: 确保用户只能访问自己的目录 diff --git a/USER_ISOLATION_IMPLEMENTATION.md b/USER_ISOLATION_IMPLEMENTATION.md new file mode 100644 index 000000000..ba4a967f4 --- /dev/null +++ b/USER_ISOLATION_IMPLEMENTATION.md @@ -0,0 +1,151 @@ +# 多用户 Workspace 隔离实施总结 + +## ✅ 已完成的修改 + +### 1. 修改 `ensure_workspace` 函数 +**文件**: `backend/app/services/agent_tools.py` + +添加了 `user_id` 参数，当提供用户 ID 时创建用户级 workspace： + +```python +async def ensure_workspace(agent_id, tenant_id=None, user_id=None): + # ... 创建共享目录 ... + + # === USER ISOLATION === + if user_id: + user_ws = ws / "users" / str(user_id) + user_ws.mkdir(parents=True, exist_ok=True) + (user_ws / "files").mkdir(exist_ok=True) + (user_ws / "sessions").mkdir(exist_ok=True) + return user_ws # 返回用户 workspace +``` + +### 2. 修改 `execute_tool` 函数 +**文件**: `backend/app/services/agent_tools.py` + +在工具执行时传入 `user_id`： + +```python +# === USER ISOLATION: Pass user_id to get user-specific workspace === +ws = await ensure_workspace(agent_id, tenant_id=_agent_tenant_id, user_id=user_id) +``` + +### 3. 修改 `_write_file` 函数 +**文件**: `backend/app/services/agent_tools.py` + +将用户文件重定向到用户目录： + +```python +def _write_file(ws, rel_path, content, tenant_id=None, user_id=None): + # ... + # === USER ISOLATION: Redirect user files to user directory === + elif rel_path.startswith("workspace/") and user_id: + user_root = (ws / "users" / str(user_id)).resolve() + sub = rel_path[len("workspace/"):].lstrip("/") + file_path = (user_root / sub).resolve() + # ... +``` + +## 📁 Workspace 目录结构 + +修改后的目录结构： + +``` +/data/agents/{agent_id}/ +├── skills/ # 共享技能目录 +├── memory/ # 共享记忆目录 +├── soul.md # 共享人格定义 +├── workspace/ # 共享工作区 +├── tasks.json # 共享任务 +└── users/ # 新增：用户隔离目录 + ├── {user_id_1}/ # 用户 1 的独立空间 + │ ├── files/ # 用户上传的文件 + │ ├── sessions/ # 用户会话数据 + │ └── memory.md # 用户个人记忆 + └── {user_id_2}/ # 用户 2 的独立空间 + ├── files/ + ├── sessions/ + └── memory.md +``` + +## 🔄 工作流程 + +### 飞书消息处理流程 + +1. 用户发送消息到飞书 bot +2. `feishu.py` 接收消息，获取 `user_id` +3. 调用 `execute_tool` 时传入 `user_id` +4. `ensure_workspace` 创建/返回用户级 workspace +5. 文件工具将文件保存到用户目录 +6. 不同用户的文件完全隔离 + +### 共享资源访问 + +- `skills/` - 所有用户共享 +- `soul.md` - 所有用户共享 +- `memory/memory.md` - 所有用户共享 +- `workspace/` - 所有用户共享（但 `workspace/` 下的用户文件隔离） + +## 🧪 测试方法 + +### 测试步骤 + +1. **用户 A 与 agent 对话并上传文件**： + ``` + 用户 A: "这是我的文档 [上传 file_a.pdf]" + ``` + 文件保存到：`/data/agents/{agent_id}/users/{user_a_id}/files/file_a.pdf` + +2. **用户 B 与同一个 agent 对话**： + ``` + 用户 B: "看看我上传的文件" + ``` + 只能看到：`/data/agents/{agent_id}/users/{user_b_id}/files/` (空目录) + +3. **验证隔离**： + - 用户 A 看不到用户 B 的文件 + - 用户 B 看不到用户 A 的文件 + - 两个用户都可以访问共享的 skills 和 soul.md + +## 📝 后续工作 + +### 需要修改的其他地方 + +1. **文件读取工具** (`_read_file`, `_list_files`) - 需要支持用户级路径 +2. **飞书文件上传** - 确保上传到用户目录 +3. **AgentBay 客户端** - 需要传递 user_id +4. **会话管理** - 在 `chat_sessions` 表中添加 `user_workspace_path` 字段 + +### 数据库迁移 + +```sql +-- 添加用户 workspace 路径字段 +ALTER TABLE chat_sessions ADD COLUMN user_workspace_path TEXT; + +-- 或者添加用户隔离标志 +ALTER TABLE chat_sessions ADD COLUMN is_user_isolated BOOLEAN DEFAULT true; +``` + +### 配置选项 + +在 agent 级别添加配置，允许选择是否启用用户隔离： + +```python +# Agent 模型添加字段 +is_user_isolation_enabled: bool = True # 默认启用 +``` + +## ⚠️ 注意事项 + +1. **向后兼容**：现有 agent 的 workspace 不受影响，只有新对话使用用户隔离 +2. **迁移脚本**：需要为现有 agent 创建迁移脚本，将现有用户文件移动到用户目录 +3. **权限检查**：确保用户只能访问自己的目录 +4. **性能影响**：每次工具执行都需要额外的路径解析 + +## 🎯 预期效果 + +- ✅ 用户 A 上传的文件，用户 B 不可见 +- ✅ 用户 A 的记忆，用户 B 不可见 +- ✅ agent 共享知识（skills, soul）仍然共享 +- ✅ 不同用户与同一 agent 对话，session 不污染 +- ✅ 飞书、微信、Web 等多个渠道的用户隔离 diff --git a/USER_WORKSPACE_ISOLATION_PLAN.md b/USER_WORKSPACE_ISOLATION_PLAN.md new file mode 100644 index 000000000..e97f6680d --- /dev/null +++ b/USER_WORKSPACE_ISOLATION_PLAN.md @@ -0,0 +1,172 @@ +# Clawith 多用户 Workspace 隔离方案 + +## 问题分析 + +当前 Clawith 的架构问题： +1. 每个 agent 只有一个 workspace：`/data/agents/{agent_id}/` +2. 多个用户与同一个 agent 对话时，共享同一个 workspace +3. 导致 session 污染：用户 A 上传的文件，用户 B 也能看到 + +## 解决方案 + +### 方案 1：用户级 Workspace 子目录（推荐） + +为每个用户在 agent workspace 下创建独立的子目录： + +``` +/data/agents/{agent_id}/ +├── skills/ # 共享技能目录 +├── memory/ # 共享记忆目录 +├── soul.md # 共享人格定义 +├── workspace/ # 共享工作区 +└── users/ # 新增：用户隔离目录 + ├── {user_id_1}/ # 用户 1 的独立空间 + │ ├── files/ # 用户上传的文件 + │ ├── sessions/ # 用户会话数据 + │ └── memory.md # 用户个人记忆 + └── {user_id_2}/ # 用户 2 的独立空间 + ├── files/ + ├── sessions/ + └── memory.md +``` + +**优点**： +- 保持 agent 共享知识（skills, soul, memory） +- 隔离用户私有文件和数据 +- 最小化代码改动 + +**需要修改的文件**： + +1. **agent_tools.py** - `ensure_workspace` 函数 + - 添加用户级目录初始化 + - 修改文件工具使用用户级路径 + +2. **feishu.py** - 消息处理 + - 在 `resolve_channel_user` 后获取用户 workspace 路径 + - 传递给工具执行上下文 + +3. **channel_session.py** - Session 管理 + - 添加用户 workspace 路径映射 + +### 方案 2：完全独立的 Agent 实例 + +为每个用户创建独立的 agent 副本： + +``` +/data/agents/ +├── {agent_id}/ # 原始 agent（模板） +├── {agent_id}_{user_id_1}/ # 用户 1 的独立 agent +└── {agent_id}_{user_id_2}/ # 用户 2 的独立 agent +``` + +**优点**： +- 完全隔离 +- 每个用户有独立的记忆、技能、配置 + +**缺点**： +- 资源浪费 +- 数据同步复杂 +- 需要修改 agent 创建逻辑 + +### 方案 3：Session 级上下文隔离 + +保持现有 workspace 结构，但在 LLM 调用时注入用户级上下文： + +```python +# 在 build_agent_context 时添加用户隔离 +async def build_agent_context(agent_id, user_id, ...): + # 加载共享 context + context = load_shared_context(agent_id) + + # 加载用户私有 context + user_context = load_user_context(agent_id, user_id) + + # 合并注入 + return context + user_context +``` + +**优点**： +- 最小改动 +- 不影响文件系统 + +**缺点**： +- 文件上传仍然共享 +- 不是真正的隔离 + +## 推荐实施方案 1 + +### 修改清单 + +#### 1. 修改 `agent_tools.py` + +```python +# 在 ensure_workspace 函数中添加用户目录 +async def ensure_workspace(agent_id: uuid.UUID, user_id: uuid.UUID = None, tenant_id: str | None = None) -> Path: + """Initialize agent workspace with standard structure.""" + ws = WORKSPACE_ROOT / str(agent_id) + ws.mkdir(parents=True, exist_ok=True) + + # 创建共享目录 + (ws / "skills").mkdir(exist_ok=True) + (ws / "memory").mkdir(exist_ok=True) + (ws / "workspace").mkdir(exist_ok=True) + + # 新增：创建用户级目录 + if user_id: + user_ws = ws / "users" / str(user_id) + user_ws.mkdir(parents=True, exist_ok=True) + (user_ws / "files").mkdir(exist_ok=True) + (user_ws / "sessions").mkdir(exist_ok=True) + + # 创建用户记忆文件 + user_memory = user_ws / "memory.md" + if not user_memory.exists(): + user_memory.write_text(f"# User Memory\n\n用户 ID: {user_id}\n", encoding="utf-8") + + return ws / "users" / str(user_id) if user_id else ws +``` + +#### 2. 修改文件上传工具 + +```python +# 在 _upload_file 等工具中使用用户级路径 +async def _upload_file(agent_id, user_id, file_data): + # 使用用户级 workspace + user_ws = await ensure_workspace(agent_id, user_id) + file_path = user_ws / "files" / filename + ... +``` + +#### 3. 修改飞书消息处理 + +```python +# 在 feishu.py 消息处理中传递 user_id +user_id = platform_user.id +user_ws = await ensure_workspace(agent_id, user_id) + +# 在工具执行上下文中使用 user_ws +``` + +### 数据库修改 + +在 `chat_sessions` 表中添加用户 workspace 路径： + +```sql +ALTER TABLE chat_sessions ADD COLUMN user_workspace_path TEXT; +``` + +## 实施步骤 + +1. **备份现有数据** +2. **修改 `agent_tools.py`** - 添加用户级 workspace 支持 +3. **修改文件工具** - 使用用户级路径 +4. **修改消息处理** - 传递 user_id 和 user_ws +5. **测试** - 验证多用户隔离 +6. **迁移脚本** - 为现有用户创建独立目录 + +## 预期效果 + +- ✅ 用户 A 上传的文件，用户 B 不可见 +- ✅ 用户 A 的记忆，用户 B 不可见 +- ✅ agent 共享知识（skills, soul）仍然共享 +- ✅ 不同用户与同一 agent 对话，session 不污染 diff --git a/backend/alembic/versions/add_user_isolation.py b/backend/alembic/versions/add_user_isolation.py new file mode 100644 index 000000000..0c7f23dbe --- /dev/null +++ b/backend/alembic/versions/add_user_isolation.py @@ -0,0 +1,31 @@ +"""add user_isolation_enabled to agents table + +Revision ID: add_user_isolation +Revises: d9cbd43b62e5 +Create Date: 2026-04-17 + +""" +from alembic import op +import sqlalchemy as sa +from sqlalchemy.dialects import postgresql + +# revision identifiers, used by Alembic. +revision = 'add_user_isolation' +down_revision = 'd9cbd43b62e5' +branch_labels = None +depends_on = None + + +def upgrade() -> None: + # Add user_isolation_enabled column to agents table + op.add_column('agents', sa.Column( + 'user_isolation_enabled', + sa.Boolean(), + nullable=False, + server_default='true', + comment='Enable user-specific workspace isolation for multi-user scenarios' + )) + + +def downgrade() -> None: + op.drop_column('agents', 'user_isolation_enabled') diff --git a/backend/app/api/agents.py b/backend/app/api/agents.py index 0f8f1bc41..6b8d57d10 100644 --- a/backend/app/api/agents.py +++ b/backend/app/api/agents.py @@ -253,6 +253,8 @@ async def create_agent( min_poll_interval_min=default_min_poll, webhook_rate_limit=default_webhook_rate, heartbeat_interval_minutes=default_heartbeat_interval, + # === USER ISOLATION === + user_isolation_enabled=data.user_isolation_enabled if hasattr(data, 'user_isolation_enabled') else True, ) if data.autonomy_policy: agent.autonomy_policy = data.autonomy_policy @@ -532,6 +534,11 @@ async def update_agent( "applied": update_data["webhook_rate_limit"], "reason": "company_ceiling", }) + + # === USER ISOLATION: Handle user_isolation_enabled === + if "user_isolation_enabled" in update_data: + # This field can be updated by creator or admin + agent.user_isolation_enabled = update_data["user_isolation_enabled"] for field, value in update_data.items(): setattr(agent, field, value) diff --git a/backend/app/api/feishu.py b/backend/app/api/feishu.py index 4751e07ec..a42660fa8 100644 --- a/backend/app/api/feishu.py +++ b/backend/app/api/feishu.py @@ -379,7 +379,29 @@ async def process_feishu_event(agent_id: uuid.UUID, body: dict, db: AsyncSession from pathlib import Path as _PostPath from app.config import get_settings as _post_gs _post_settings = _post_gs() - _upload_dir = _PostPath(_post_settings.AGENT_DATA_DIR) / str(agent_id) / "workspace" / "uploads" + + # === USER ISOLATION: Check if user isolation is enabled === + _use_user_workspace = False + _user_id_for_upload = None + if sender_open_id: + try: + from uuid import UUID as _UUID + _user_uuid = _UUID(sender_open_id) + _user_id_for_upload = _user_uuid + async with _async_session() as _db: + _agent_check = await _db.execute(_select(AgentModel).where(AgentModel.id == agent_id)) + _agent_obj_check = _agent_check.scalar_one_or_none() + if _agent_obj_check and getattr(_agent_obj_check, 'user_isolation_enabled', False): + _use_user_workspace = True + except Exception: + pass + + # Determine upload directory + if _use_user_workspace and _user_id_for_upload: + _upload_dir = _PostPath(_post_settings.AGENT_DATA_DIR) / str(agent_id) / "users" / str(_user_id_for_upload) / "files" + else: + _upload_dir = _PostPath(_post_settings.AGENT_DATA_DIR) / str(agent_id) / "workspace" / "uploads" + _upload_dir.mkdir(parents=True, exist_ok=True) for _ik in _post_image_keys: try: @@ -435,6 +457,21 @@ async def process_feishu_event(agent_id: uuid.UUID, body: dict, db: AsyncSession conv_id = f"feishu_group_{chat_id}" else: conv_id = f"feishu_p2p_{sender_user_id_from_event or sender_open_id}" + + # Check Redis cache for user-selected new session + # Key format: feishu_session:{agent_id}:{user_id} + try: + import redis as _redis + _r = _redis.Redis(host='clawith-redis', port=6379, db=0, decode_responses=True) + _cache_key = f"feishu_session:{agent_id}:{platform_user_id if 'platform_user_id' in dir() else sender_open_id}" + _cached_session_id = _r.get(_cache_key) + if _cached_session_id: + # User previously requested new session, use cached session's external_conv_id + conv_id = _cached_session_id + logger.info(f"[Feishu] Using cached session: {conv_id}") + _r.close() + except Exception as _e: + logger.debug(f"[Feishu] Redis cache check failed: {_e}") # Load recent conversation history via session (session UUID may already exist) from app.models.audit import ChatMessage @@ -562,6 +599,30 @@ async def process_feishu_event(agent_id: uuid.UUID, body: dict, db: AsyncSession ) platform_user_id = platform_user.id + # ── Check for "new session" command ── + # User can send "/new" or "新建对话" to start a new session + _user_text_lower = user_text.strip().lower() + _should_create_new_session = _user_text_lower in ["/new", "/n", "新建对话", "新对话", "new session", "start new"] + + if _should_create_new_session: + # Create a new session with a fresh conv_id + import uuid as _uuid + new_conv_id = f"feishu_new_{_uuid.uuid4().hex[:8]}" + conv_id = new_conv_id + logger.info(f"[Feishu] User requested new session: {new_conv_id}") + + # Cache the new session ID to Redis for subsequent messages + # TTL: 24 hours (user has 24h to continue the new session) + try: + import redis as _redis + _r = _redis.Redis(host='clawith-redis', port=6379, db=0, decode_responses=True) + _cache_key = f"feishu_session:{agent_id}:{platform_user_id}" + _r.setex(_cache_key, 86400, new_conv_id) # 24 hours TTL + _r.close() + logger.info(f"[Feishu] Cached new session: {_cache_key} -> {new_conv_id}") + except Exception as _e: + logger.error(f"[Feishu] Redis cache write failed: {_e}") + # ── Find-or-create a ChatSession via external_conv_id (DB-based, no cache needed) ── from datetime import datetime as _dt, timezone as _tz _is_group = (chat_type == "group") @@ -1070,6 +1131,23 @@ async def _heartbeat(): # Save assistant reply to history (use platform_user_id so messages stay in one session) db.add(ChatMessage(agent_id=agent_id, user_id=platform_user_id, role="assistant", content=reply_text, conversation_id=session_conv_id)) _sess.last_message_at = _dt.now(_tz.utc) + + # If new session was created, inform the user + if _should_create_new_session: + # Send a follow-up message to notify about new session + try: + import json as _j + _welcome_msg = "✅ 已创建新对话！之前的聊天记录不会受影响。" + await feishu_service.send_message( + config.app_id, config.app_secret, + chat_id if chat_type == "group" else sender_open_id, + "text", + _j.dumps({"text": _welcome_msg}), + receive_id_type="chat_id" if chat_type == "group" else "open_id" + ) + except Exception as e: + logger.error(f"[Feishu] Failed to send new session notification: {e}") + await db.commit() return {"code": 0, "msg": "ok"} @@ -1118,19 +1196,12 @@ async def _handle_feishu_file(db, agent_id, config, message, sender_open_id, cha logger.warning(f"[Feishu] No file_key in {msg_type} message") return - # Resolve workspace upload dir - settings = get_settings() - upload_dir = Path(settings.AGENT_DATA_DIR) / str(agent_id) / "workspace" / "uploads" - upload_dir.mkdir(parents=True, exist_ok=True) - save_path = upload_dir / filename - - # Download the file + # Download the file first + file_bytes = None try: file_bytes = await feishu_service.download_message_resource( config.app_id, config.app_secret, message_id, file_key, res_type ) - save_path.write_bytes(file_bytes) - logger.info(f"[Feishu] Saved {msg_type} to {save_path} ({len(file_bytes)} bytes)") except Exception as e: logger.error(f"[Feishu] Failed to download {msg_type}: {e}") err_tip = "抱歉，文件下载失败。可能原因：机器人缺少 `im:resource` 权限（文件读取）。\n请在飞书开放平台 → 权限管理 → 批量导入权限 JSON → 重新发布机器人版本后重试。" @@ -1170,8 +1241,6 @@ async def _handle_feishu_file(db, agent_id, config, message, sender_open_id, cha if _ud.get("code") == 0: _user_info = _ud.get("data", {}).get("user", {}) sender_user_id_feishu = _user_info.get("user_id", "") - # Feishu contact API returns 'avatar' as a dict - # (keys: avatar_240, avatar_640, avatar_origin), NOT a plain URL. _raw_avatar = _user_info.get("avatar") if isinstance(_raw_avatar, dict): _avatar_url = ( @@ -1194,7 +1263,7 @@ async def _handle_feishu_file(db, agent_id, config, message, sender_open_id, cha except Exception: pass - # Resolve channel user via unified service (uses OrgMember + SSO patterns) + # Resolve channel user via unified service from app.services.channel_user_service import channel_user_service platform_user = await channel_user_service.resolve_channel_user( db=db, @@ -1203,6 +1272,29 @@ async def _handle_feishu_file(db, agent_id, config, message, sender_open_id, cha external_user_id=sender_open_id, extra_info=extra_info, ) + + # === USER ISOLATION: Check if user isolation is enabled === + use_user_workspace = False + user_id_for_upload = None + + if platform_user: + user_id_for_upload = str(platform_user.id) + if agent_obj and getattr(agent_obj, 'user_isolation_enabled', False): + use_user_workspace = True + + # Determine upload directory + settings = get_settings() + if use_user_workspace and user_id_for_upload: + upload_dir = Path(settings.AGENT_DATA_DIR) / str(agent_id) / "users" / str(user_id_for_upload) / "files" + else: + upload_dir = Path(settings.AGENT_DATA_DIR) / str(agent_id) / "workspace" / "uploads" + + upload_dir.mkdir(parents=True, exist_ok=True) + save_path = upload_dir / filename + + # Save the file + save_path.write_bytes(file_bytes) + logger.info(f"[Feishu] Saved {msg_type} to {save_path} ({len(file_bytes)} bytes)") platform_user_id = platform_user.id # Conv ID — prefer user_id for session continuity diff --git a/backend/app/api/user_workspaces.py b/backend/app/api/user_workspaces.py new file mode 100644 index 000000000..257103c19 --- /dev/null +++ b/backend/app/api/user_workspaces.py @@ -0,0 +1,261 @@ +"""User workspace isolation APIs.""" + +import uuid +from fastapi import APIRouter, Depends, HTTPException, status, UploadFile, Form +from sqlalchemy import select +from sqlalchemy.ext.asyncio import AsyncSession + +from app.core.security import get_current_user +from app.database import get_db +from app.models.user import User +from app.models.agent import Agent as AgentModel +from pathlib import Path +from app.config import get_settings + +settings = get_settings() +WORKSPACE_ROOT = Path(settings.AGENT_DATA_DIR) + +router = APIRouter(prefix="/agents/{agent_id}/user-workspaces", tags=["user-workspaces"]) + + +@router.get("/users") +async def list_agent_users( + agent_id: uuid.UUID, + current_user: User = Depends(get_current_user), + db: AsyncSession = Depends(get_db), +): + """List all users who have interacted with this agent. + + Only accessible by agent creator or admin. + """ + # Check permission + result = await db.execute(select(AgentModel).where(AgentModel.id == agent_id)) + agent = result.scalar_one_or_none() + if not agent: + raise HTTPException(status_code=404, detail="Agent not found") + + is_creator = agent.creator_id == current_user.id + is_admin = current_user.role in ("platform_admin", "org_admin") + + if not is_creator and not is_admin: + raise HTTPException(status_code=403, detail="Only creator or admin can access user list") + + # Find all users who have workspaces under this agent + agent_dir = WORKSPACE_ROOT / str(agent_id) + users_dir = agent_dir / "users" + + if not users_dir.exists(): + return {"users": []} + + user_ids = [] + for entry in users_dir.iterdir(): + if entry.is_dir(): + try: + user_uuid = uuid.UUID(entry.name) + user_ids.append(str(user_uuid)) + except ValueError: + continue + + # Get user details from database + from app.models.user import User as UserModel + user_result = await db.execute( + select(UserModel).where(UserModel.id.in_(user_ids)) + ) + users = user_result.scalars().all() + + return { + "users": [ + { + "id": str(u.id), + "display_name": u.display_name, + "avatar_url": u.avatar_url, + } + for u in users + ] + } + + +@router.get("/users/{user_id}/files") +async def list_user_files( + agent_id: uuid.UUID, + user_id: uuid.UUID, + path: str = "", + current_user: User = Depends(get_current_user), + db: AsyncSession = Depends(get_db), +): + """List files in a user's workspace. + + Users can only access their own files. + Admins/creators can access any user's files. + """ + # Check permission + if user_id != current_user.id: + result = await db.execute(select(AgentModel).where(AgentModel.id == agent_id)) + agent = result.scalar_one_or_none() + if not agent: + raise HTTPException(status_code=404, detail="Agent not found") + + is_creator = agent.creator_id == current_user.id + is_admin = current_user.role in ("platform_admin", "org_admin") + + if not is_creator and not is_admin: + raise HTTPException(status_code=403, detail="Cannot access other user's workspace") + + # Build path - user files are stored in users/{user_id}/files/ + agent_dir = WORKSPACE_ROOT / str(agent_id) + user_dir = agent_dir / "users" / str(user_id) / "files" + + if not user_dir.exists(): + return {"files": [], "directories": []} + + # Resolve and canonicalize path to prevent directory traversal + target_path = (user_dir / path).resolve() + user_dir_resolved = user_dir.resolve() + + if not str(target_path).startswith(str(user_dir_resolved)): + raise HTTPException(status_code=403, detail="Access denied - invalid path") + + if not target_path.exists(): + raise HTTPException(status_code=404, detail="Path not found") + + files = [] + directories = [] + + for entry in target_path.iterdir(): + if entry.name.startswith("."): + continue + if entry.is_file(): + files.append({ + "name": entry.name, + "path": str(entry.relative_to(user_dir)), + "size": entry.stat().st_size, + }) + elif entry.is_dir(): + directories.append({ + "name": entry.name, + "path": str(entry.relative_to(user_dir)), + }) + + return { + "files": files, + "directories": directories, + "current_path": str(target_path.relative_to(user_dir)) if path else "", + } + + +@router.get("/users/{user_id}/memory") +async def get_user_memory( + agent_id: uuid.UUID, + user_id: uuid.UUID, + current_user: User = Depends(get_current_user), + db: AsyncSession = Depends(get_db), +): + """Get user's personal memory. + + Users can only access their own memory. + Admins/creators can access any user's memory. + """ + # Check permission (same as list_user_files) + if user_id != current_user.id: + result = await db.execute(select(AgentModel).where(AgentModel.id == agent_id)) + agent = result.scalar_one_or_none() + if not agent: + raise HTTPException(status_code=404, detail="Agent not found") + + is_creator = agent.creator_id == current_user.id + is_admin = current_user.role in ("platform_admin", "org_admin") + + if not is_creator and not is_admin: + raise HTTPException(status_code=403, detail="Cannot access other user's workspace") + + # Read memory file + agent_dir = WORKSPACE_ROOT / str(agent_id) + user_dir = agent_dir / "users" / str(user_id) + memory_file = user_dir / "memory.md" + + if not memory_file.exists(): + return {"content": ""} + + return {"content": memory_file.read_text(encoding="utf-8")} + + +@router.put("/users/{user_id}/memory") +async def update_user_memory( + agent_id: uuid.UUID, + user_id: uuid.UUID, + content: str = Form(...), + current_user: User = Depends(get_current_user), + db: AsyncSession = Depends(get_db), +): + """Update user's personal memory. + + Users can only update their own memory. + Admins/creators can update any user's memory. + """ + # Check permission + if user_id != current_user.id: + result = await db.execute(select(AgentModel).where(AgentModel.id == agent_id)) + agent = result.scalar_one_or_none() + if not agent: + raise HTTPException(status_code=404, detail="Agent not found") + + is_creator = agent.creator_id == current_user.id + is_admin = current_user.role in ("platform_admin", "org_admin") + + if not is_creator and not is_admin: + raise HTTPException(status_code=403, detail="Cannot access other user's workspace") + + # Write memory file + agent_dir = WORKSPACE_ROOT / str(agent_id) + user_dir = agent_dir / "users" / str(user_id) + user_dir.mkdir(parents=True, exist_ok=True) + + memory_file = user_dir / "memory.md" + memory_file.write_text(content, encoding="utf-8") + + return {"success": True} + + +@router.post("/users/{user_id}/files/upload") +async def upload_user_file( + agent_id: uuid.UUID, + user_id: uuid.UUID, + file: UploadFile, + path: str = Form(...), + current_user: User = Depends(get_current_user), + db: AsyncSession = Depends(get_db), +): + """Upload a file to user's workspace. + + Users can only upload to their own files. + Admins/creators can upload to any user's files. + """ + # Check permission + if user_id != current_user.id: + result = await db.execute(select(AgentModel).where(AgentModel.id == agent_id)) + agent = result.scalar_one_or_none() + if not agent: + raise HTTPException(status_code=404, detail="Agent not found") + + is_creator = agent.creator_id == current_user.id + is_admin = current_user.role in ("platform_admin", "org_admin") + + if not is_creator and not is_admin: + raise HTTPException(status_code=403, detail="Cannot access other user's workspace") + + # Create user directory + agent_dir = WORKSPACE_ROOT / str(agent_id) + user_dir = agent_dir / "users" / str(user_id) / "files" + user_dir.mkdir(parents=True, exist_ok=True) + + # Save file + file_path = user_dir / file.filename + content = await file.read() + file_path.write_bytes(content) + + return { + "success": True, + "path": str(file_path.relative_to(user_dir.parent)), + "filename": file.filename, + "size": len(content), + } diff --git a/backend/app/api/wecom.py b/backend/app/api/wecom.py index 8aaa30469..19bc3549f 100644 --- a/backend/app/api/wecom.py +++ b/backend/app/api/wecom.py @@ -32,7 +32,7 @@ from app.models.identity import IdentityProvider, SSOScanSession from app.models.user import User from app.services.activity_logger import log_activity -from app.services.auth_provider import auth_provider_registry +from app.services.auth_registry import auth_provider_registry from app.services.channel_session import find_or_create_channel_session from app.services.channel_user_service import channel_user_service from app.services.platform_service import platform_service diff --git a/backend/app/main.py b/backend/app/main.py index 896976db5..165cddcea 100644 --- a/backend/app/main.py +++ b/backend/app/main.py @@ -286,6 +286,7 @@ def _bg_task_error(t): from app.api.plaza import router as plaza_router from app.api.skills import router as skills_router from app.api.users import router as users_router +from app.api.user_workspaces import router as user_workspaces_router from app.api.chat_sessions import router as chat_sessions_router from app.api.slack import router as slack_router from app.api.discord_bot import router as discord_router @@ -324,6 +325,7 @@ def _bg_task_error(t): app.include_router(enterprise_kb_router, prefix=settings.API_PREFIX) app.include_router(skills_router, prefix=settings.API_PREFIX) app.include_router(users_router, prefix=settings.API_PREFIX) +app.include_router(user_workspaces_router, prefix=settings.API_PREFIX) app.include_router(slack_router, prefix=settings.API_PREFIX) app.include_router(discord_router, prefix=settings.API_PREFIX) app.include_router(dingtalk_router, prefix=settings.API_PREFIX) diff --git a/backend/app/models/agent.py b/backend/app/models/agent.py index 8cb129f7a..d2b5bd0c9 100644 --- a/backend/app/models/agent.py +++ b/backend/app/models/agent.py @@ -78,6 +78,10 @@ class Agent(Base): tokens_used_today: Mapped[int] = mapped_column(Integer, default=0) tokens_used_month: Mapped[int] = mapped_column(Integer, default=0) last_daily_reset: Mapped[datetime | None] = mapped_column(DateTime(timezone=True)) + + # === USER ISOLATION: Enable user-specific workspace === + user_isolation_enabled: Mapped[bool] = mapped_column(Boolean, default=True, nullable=False, + comment='Enable user-specific workspace isolation for multi-user scenarios') last_monthly_reset: Mapped[datetime | None] = mapped_column(DateTime(timezone=True)) tokens_used_total: Mapped[int] = mapped_column(Integer, default=0) context_window_size: Mapped[int] = mapped_column(Integer, default=100) diff --git a/backend/app/schemas/schemas.py b/backend/app/schemas/schemas.py index 3870392b9..bcc1f7655 100644 --- a/backend/app/schemas/schemas.py +++ b/backend/app/schemas/schemas.py @@ -228,6 +228,8 @@ class AgentCreate(BaseModel): # Token limits max_tokens_per_day: int | None = None max_tokens_per_month: int | None = None + # === USER ISOLATION: Enable user-specific workspace === + user_isolation_enabled: bool = True # Skills to copy into agent workspace skill_ids: list[uuid.UUID] = [] @@ -270,6 +272,8 @@ class AgentOut(BaseModel): api_key_hash: str | None = None created_at: datetime last_active_at: datetime | None = None + # === USER ISOLATION === + user_isolation_enabled: bool = True model_config = {"from_attributes": True} @@ -295,6 +299,8 @@ class AgentUpdate(BaseModel): heartbeat_active_hours: str | None = None timezone: str | None = None expires_at: datetime | None = None # Admin only — extend agent expiry + # === USER ISOLATION === + user_isolation_enabled: bool | None = None class AgentStatusOut(BaseModel): diff --git a/backend/app/services/agent_context.py b/backend/app/services/agent_context.py index 84ebaece2..68df11420 100644 --- a/backend/app/services/agent_context.py +++ b/backend/app/services/agent_context.py @@ -145,29 +145,48 @@ def _load_skills_index(agent_id: uuid.UUID) -> str: lines.append("2. Follow the loaded instructions to complete the task.") lines.append("3. Do NOT guess what the skill contains — always read it first.") lines.append("4. Folder-based skills may contain auxiliary files (scripts/, references/, examples/). Use `list_files` on the skill folder to discover them.") + lines.append("5. **YOU CAN CREATE NEW SKILLS**: Use `write_file` to create new skill files in `skills/` directory (e.g., `skills/my-new-skill.md` or `skills/my-new-skill/SKILL.md`). You have full permission to create, modify, and delete skill files.") return "\n".join(lines) -async def build_agent_context(agent_id: uuid.UUID, agent_name: str, role_description: str = "", current_user_name: str = None) -> tuple[str, str]: +async def build_agent_context(agent_id: uuid.UUID, agent_name: str, role_description: str = "", current_user_name: str = None, current_user_id: str | None = None) -> tuple[str, str]: """Build a rich system prompt incorporating agent's full context. Reads from workspace files: - - soul.md → personality - - memory.md → long-term memory - - skills/ → skill names + summaries - - relationships.md → relationship descriptions + - soul.md → personality (shared) + - memory.md → long-term memory (shared) + - users/{user_id}/memory.md → user-specific memory (if user isolation enabled) + - skills/ → skill names + summaries (shared) + - relationships.md → relationship descriptions (shared) + + Args: + agent_id: Agent UUID + agent_name: Agent name + role_description: Agent role description + current_user_name: Current user's display name + current_user_id: Current user's UUID (for user-specific memory) """ ws_root = _agent_workspace(agent_id) - # --- Soul --- + # --- Soul (shared) --- soul = _read_file_safe(ws_root / "soul.md", 2000) # Strip markdown heading if present if soul.startswith("# "): soul = "\n".join(soul.split("\n")[1:]).strip() # --- Memory --- - memory = _read_file_safe(ws_root / "memory" / "memory.md", 2000) or _read_file_safe(ws_root / "memory.md", 2000) + # Priority: user-specific memory > shared memory + memory = "" + if current_user_id: + # Try user-specific memory first + user_memory_path = ws_root / "users" / current_user_id / "memory.md" + memory = _read_file_safe(user_memory_path, 2000) + + # Fall back to shared memory if no user-specific memory + if not memory: + memory = _read_file_safe(ws_root / "memory" / "memory.md", 2000) or _read_file_safe(ws_root / "memory.md", 2000) + if memory.startswith("# "): memory = "\n".join(memory.split("\n")[1:]).strip() diff --git a/backend/app/services/agent_tools.py b/backend/app/services/agent_tools.py index 98b99fce3..a336e6848 100644 --- a/backend/app/services/agent_tools.py +++ b/backend/app/services/agent_tools.py @@ -33,7 +33,6 @@ from app.models.chat_session import ChatSession from app.models.channel_config import ChannelConfig from app.models.user import User as UserModel -from app.services.auth_registry import auth_provider_registry from app.services.channel_session import find_or_create_channel_session from app.services.channel_user_service import get_platform_user_by_org_member from app.config import get_settings @@ -1946,12 +1945,21 @@ async def get_agent_tools_for_llm(agent_id: uuid.UUID) -> list[dict]: # ─── Workspace initialization ────────────────────────────────── -async def ensure_workspace(agent_id: uuid.UUID, tenant_id: str | None = None) -> Path: - """Initialize agent workspace with standard structure.""" +async def ensure_workspace(agent_id: uuid.UUID, tenant_id: str | None = None, user_id: uuid.UUID | None = None) -> Path: + """Initialize agent workspace with standard structure. + + Args: + agent_id: Agent UUID + tenant_id: Optional tenant ID for enterprise_info + user_id: Optional user ID for user-isolated workspace + + Returns: + Path to workspace root (user workspace if user_id provided and isolation enabled, else agent workspace) + """ ws = WORKSPACE_ROOT / str(agent_id) ws.mkdir(parents=True, exist_ok=True) - # Create standard directories + # Create standard directories (shared across all users) (ws / "skills").mkdir(exist_ok=True) (ws / "workspace").mkdir(exist_ok=True) (ws / "workspace" / "knowledge_base").mkdir(exist_ok=True) @@ -1982,7 +1990,6 @@ async def ensure_workspace(agent_id: uuid.UUID, tenant_id: str | None = None) -> # Try to load from DB try: async with async_session() as db: - r = await db.execute(select(AgentModel).where(AgentModel.id == agent_id)) agent = r.scalar_one_or_none() if agent and agent.role_description: @@ -1995,6 +2002,39 @@ async def ensure_workspace(agent_id: uuid.UUID, tenant_id: str | None = None) -> except Exception: (ws / "soul.md").write_text("# Personality\n\n_Describe your role and responsibilities._\n", encoding="utf-8") + # === USER ISOLATION: Create user-specific workspace === + # Only if user_id is provided AND user isolation is enabled for this agent + if user_id: + # Check if user isolation is enabled for this agent + user_isolation_enabled = True # Default to True + try: + async with async_session() as db: + r = await db.execute(select(AgentModel).where(AgentModel.id == agent_id)) + agent = r.scalar_one_or_none() + if agent and hasattr(agent, 'user_isolation_enabled'): + user_isolation_enabled = agent.user_isolation_enabled + except Exception as e: + logger.warning(f"Failed to check user_isolation_enabled for agent {agent_id}: {e}") + + if user_isolation_enabled: + user_ws = ws / "users" / str(user_id) + user_ws.mkdir(parents=True, exist_ok=True) + + # Create user directories + (user_ws / "files").mkdir(exist_ok=True) + (user_ws / "sessions").mkdir(exist_ok=True) + + # Create user memory file + user_memory = user_ws / "memory.md" + if not user_memory.exists(): + user_memory.write_text( + f"# User Memory\n\n用户 ID: {user_id}\n\n_记录与这个 agent 的私人对话记忆。_\n", + encoding="utf-8" + ) + + # Return user workspace path + return user_ws + # Always sync tasks from DB await _sync_tasks_to_file(agent_id, ws) @@ -2125,7 +2165,8 @@ async def execute_tool( """ _agent_tenant_id = await _get_agent_tenant_id(agent_id) - ws = await ensure_workspace(agent_id, tenant_id=_agent_tenant_id) + # === USER ISOLATION: Pass user_id to get user-specific workspace === + ws = await ensure_workspace(agent_id, tenant_id=_agent_tenant_id, user_id=user_id) # ── Autonomy boundary check ── action_type = _TOOL_AUTONOMY_MAP.get(tool_name) @@ -2170,20 +2211,20 @@ async def execute_tool( try: if tool_name == "list_files": - result = _list_files(ws, arguments.get("path", ""), tenant_id=_agent_tenant_id) + result = _list_files(ws, arguments.get("path", ""), tenant_id=_agent_tenant_id, user_id=user_id) elif tool_name == "read_file": path = arguments.get("path") if not path: return "❌ Missing required argument 'path' for read_file" offset = int(arguments.get("offset", 0)) limit = int(arguments.get("limit", 2000)) - result = _read_file(ws, path, tenant_id=_agent_tenant_id, offset=offset, limit=limit) + result = _read_file(ws, path, tenant_id=_agent_tenant_id, offset=offset, limit=limit, user_id=user_id) elif tool_name == "read_document": path = arguments.get("path") if not path: return "❌ Missing required argument 'path' for read_document" max_chars = min(int(arguments.get("max_chars", 8000)), 20000) - result = await _read_document(ws, path, max_chars=max_chars, tenant_id=_agent_tenant_id) + result = await _read_document(ws, path, max_chars=max_chars, tenant_id=_agent_tenant_id, user_id=user_id) elif tool_name == "write_file": path = arguments.get("path") content = arguments.get("content") @@ -2191,7 +2232,7 @@ async def execute_tool( return "❌ Missing required argument 'path' for write_file. Please provide a file path like 'skills/my-skill/SKILL.md'" if content is None: return "❌ Missing required argument 'content' for write_file" - result = _write_file(ws, path, content, tenant_id=_agent_tenant_id) + result = _write_file(ws, path, content, tenant_id=_agent_tenant_id, user_id=user_id) elif tool_name == "delete_file": result = _delete_file(ws, arguments.get("path", "")) # --- Enhanced file management tools --- @@ -2864,7 +2905,21 @@ async def _send_channel_file(agent_id: uuid.UUID, ws: Path, arguments: dict) -> return "Error: file_path is required" # Resolve file path within agent workspace - file_path = (ws / rel_path).resolve() + # Handle workspace/ prefix in rel_path + if rel_path.startswith("workspace/"): + rel_path = rel_path[len("workspace/"):] + + # Check if ws is user-specific workspace (path contains /users/{uuid}) + import re as _re + is_user_ws = bool(_re.search(r'/users/[0-9a-f-]{36}$', str(ws))) + + if is_user_ws: + # User workspace: files are in users/{user_id}/files/ + file_path = (ws / "files" / rel_path).resolve() + else: + # Agent workspace: use relative path + file_path = (ws / rel_path).resolve() + ws_resolved = ws.resolve() if not str(file_path).startswith(str(ws_resolved)): file_path = (WORKSPACE_ROOT / str(agent_id) / rel_path).resolve() @@ -2913,7 +2968,7 @@ async def _send_file_to_recipient( agent_id: uuid.UUID, file_path: Path, member_name: str, message: str = "" ) -> str | None: """Resolve a recipient by name and send file via their reachable channel. - + Checks Feishu and Slack channels configured for this agent. Returns a result string, or None if no channel found. """ @@ -2926,20 +2981,29 @@ async def _send_file_to_recipient( ) configs = {c.channel_type: c for c in result.scalars().all()} + logger.info(f"[send_file_to_recipient] Trying to send '{file_path.name}' to '{member_name}'. Configs: {list(configs.keys())}") + # --- Try Feishu --- feishu_config = configs.get("feishu") if feishu_config: + logger.info(f"[send_file_to_recipient] Trying Feishu...") feishu_result = await _send_file_via_feishu(agent_id, feishu_config, file_path, member_name, message) if feishu_result: + logger.info(f"[send_file_to_recipient] Feishu success: {feishu_result}") return feishu_result + logger.warning(f"[send_file_to_recipient] Feishu failed - recipient '{member_name}' not found") # --- Try Slack --- slack_config = configs.get("slack") if slack_config: + logger.info(f"[send_file_to_recipient] Trying Slack...") slack_result = await _send_file_via_slack(agent_id, slack_config, file_path, member_name, message) if slack_result: + logger.info(f"[send_file_to_recipient] Slack success: {slack_result}") return slack_result + logger.warning(f"[send_file_to_recipient] Slack failed - recipient '{member_name}' not found") + logger.error(f"[send_file_to_recipient] All channels failed for '{member_name}'") return None # No channel could reach this recipient @@ -3339,7 +3403,18 @@ async def _smithery_auto_recover(api_key: str, mcp_url: str, namespace: str, con return f"❌ Auto-recovery failed: {str(e)[:200]}" -def _list_files(ws: Path, rel_path: str, tenant_id: str | None = None) -> str: +def _list_files(ws: Path, rel_path: str, tenant_id: str | None = None, user_id: uuid.UUID | None = None) -> str: + """List files in workspace or user's personal space. + + Args: + ws: Workspace root (may be user-specific if user isolation is enabled) + rel_path: Relative path to list + tenant_id: Optional tenant ID for enterprise_info + user_id: Optional user ID for user-specific paths + """ + # === USER ISOLATION: Check if ws is already user-specific === + is_user_ws = user_id and str(ws).endswith(f"users/{user_id}") + # Handle enterprise_info/ as shared directory (tenant-scoped) if rel_path and rel_path.startswith("enterprise_info"): if tenant_id: @@ -3351,6 +3426,30 @@ def _list_files(ws: Path, rel_path: str, tenant_id: str | None = None) -> str: target = (enterprise_root / sub).resolve() if sub else enterprise_root if not str(target).startswith(str(enterprise_root)): return "Access denied for this path" + # === USER ISOLATION: Also check user's personal files directory === + elif rel_path and rel_path.startswith("users/") and user_id: + # Allow accessing user's own files via users/{user_id}/files/ path + user_root = (ws / "users" / str(user_id)).resolve() + sub = rel_path[len("users/") + len(str(user_id)) + 1:].lstrip("/") + target = (user_root / sub).resolve() if sub else user_root + if not str(target).startswith(str(user_root)): + return "Access denied for this path" + # Also support workspace/uploads/ for backward compatibility + elif rel_path and rel_path.startswith("workspace/"): + sub = rel_path[len("workspace/"):].lstrip("/") + if user_id: + # For user isolation, workspace/uploads goes to user's files + target = (ws / "users" / str(user_id) / "files" / sub).resolve() + else: + target = (ws / "workspace" / sub).resolve() + if not str(target).startswith(str(ws.resolve())) and not (user_id and str(target).startswith(str(ws / "users" / str(user_id)))): + return "Access denied for this path" + # === USER ISOLATION: If user workspace and no path, show user's files === + elif is_user_ws and not rel_path: + # User workspace root - show user's files directory + target = ws / "files" + if not target.exists(): + return f"📂 users/{user_id}/: Empty directory (0 files, 0 folders)" else: target = (ws / rel_path) if rel_path else ws target = target.resolve() @@ -3362,7 +3461,7 @@ def _list_files(ws: Path, rel_path: str, tenant_id: str | None = None) -> str: items = [] # If listing root, also show enterprise_info entry - if not rel_path: + if not rel_path and not is_user_ws: if tenant_id: enterprise_dir = WORKSPACE_ROOT / f"enterprise_info_{tenant_id}" else: @@ -3386,16 +3485,22 @@ def _list_files(ws: Path, rel_path: str, tenant_id: str | None = None) -> str: size_str = f"{size_bytes}B" else: size_str = f"{size_bytes/1024:.1f}KB" - items.append(f" 📄 {p.name} ({size_str})") + # If in user workspace, show path as workspace/filename + if is_user_ws: + items.append(f" 📄 workspace/{p.name} ({size_str})") + else: + items.append(f" 📄 {p.name} ({size_str})") if not items: + if is_user_ws: + return f"📂 workspace/: Empty directory (0 files, 0 folders)" return f"📂 {rel_path or 'root'}: Empty directory (0 files, 0 folders)" - header = f"📂 {rel_path or 'root'}: {dir_count} folder(s), {file_count} file(s)\n" + header = f"📂 {rel_path or 'workspace' if is_user_ws else 'root'}: {dir_count} folder(s), {file_count} file(s)\n" return header + "\n".join(items) -def _read_file(ws: Path, rel_path: str, tenant_id: str | None = None, offset: int = 0, limit: int = 2000) -> str: +def _read_file(ws: Path, rel_path: str, tenant_id: str | None = None, offset: int = 0, limit: int = 2000, user_id: uuid.UUID | None = None) -> str: """Read file contents with optional line range support. Args: @@ -3404,6 +3509,7 @@ def _read_file(ws: Path, rel_path: str, tenant_id: str | None = None, offset: in tenant_id: Optional tenant ID for enterprise_info offset: Starting line number (0-indexed) limit: Maximum number of lines to read + user_id: Optional user ID for user-specific paths Returns: File content with line numbers, or error message @@ -3418,6 +3524,20 @@ def _read_file(ws: Path, rel_path: str, tenant_id: str | None = None, offset: in file_path = (enterprise_root / sub).resolve() if sub else enterprise_root if not str(file_path).startswith(str(enterprise_root)): return "Access denied for this path" + # === USER ISOLATION: Support user-specific paths === + elif rel_path and rel_path.startswith("workspace/") and user_id: + # Check if ws is already user-specific + is_user_ws = str(ws).endswith(f"/users/{user_id}") + if is_user_ws: + # ws is users/{user_id}, so workspace/xxx → files/xxx + sub = rel_path[len("workspace/"):].lstrip("/") + file_path = (ws / "files" / sub).resolve() + else: + # ws is agent root, workspace/xxx → users/{user_id}/files/xxx + sub = rel_path[len("workspace/"):].lstrip("/") + file_path = (ws / "users" / str(user_id) / "files" / sub).resolve() + if not str(file_path).startswith(str(ws.resolve())): + return "Access denied for this path" else: file_path = (ws / rel_path).resolve() if not str(file_path).startswith(str(ws.resolve())): @@ -3459,8 +3579,19 @@ def _read_file(ws: Path, rel_path: str, tenant_id: str | None = None, offset: in return f"Read failed: {e}" -async def _read_document(ws: Path, rel_path: str, max_chars: int = 8000, tenant_id: str | None = None) -> str: - """Read content from office documents (PDF, DOCX, XLSX, PPTX).""" +async def _read_document(ws: Path, rel_path: str, max_chars: int = 8000, tenant_id: str | None = None, user_id: uuid.UUID | None = None) -> str: + """Read content from office documents (PDF, DOCX, XLSX, PPTX). + + Args: + ws: Workspace root (may be user-specific if user isolation is enabled) + rel_path: Relative file path + max_chars: Maximum characters to return + tenant_id: Optional tenant ID for enterprise_info + user_id: Optional user ID for user-specific paths + """ + # === USER ISOLATION: Check if ws is already user-specific === + is_user_ws = user_id and str(ws).endswith(f"users/{user_id}") + # Handle enterprise_info/ as shared directory (tenant-scoped) if rel_path and rel_path.startswith("enterprise_info"): if tenant_id: @@ -3471,6 +3602,20 @@ async def _read_document(ws: Path, rel_path: str, max_chars: int = 8000, tenant_ file_path = (enterprise_root / sub).resolve() if sub else enterprise_root if not str(file_path).startswith(str(enterprise_root)): return "Access denied for this path" + # === USER ISOLATION: Support workspace/uploads/ path === + elif rel_path and rel_path.startswith("workspace/"): + sub = rel_path[len("workspace/"):].lstrip("/") + if is_user_ws: + # ws is already users/{user_id}, so just append files/ + file_path = (ws / "files" / sub).resolve() + elif user_id: + # ws is agent root, map to users/{user_id}/files/ + file_path = (ws / "users" / str(user_id) / "files" / sub).resolve() + else: + # No user isolation, use shared workspace/uploads/ + file_path = (ws / "workspace" / sub).resolve() + if not str(file_path).startswith(str(ws.resolve())): + return "Access denied for this path" else: file_path = (ws / rel_path).resolve() if not str(file_path).startswith(str(ws.resolve())): @@ -3586,7 +3731,16 @@ def _extract_table(table) -> str: return f"Document read failed: {str(e)[:200]}" -def _write_file(ws: Path, rel_path: str, content: str, tenant_id: str | None = None) -> str: +def _write_file(ws: Path, rel_path: str, content: str, tenant_id: str | None = None, user_id: uuid.UUID | None = None) -> str: + """Write file to workspace. + + Args: + ws: Workspace root path (may be user-specific workspace) + rel_path: Relative file path + content: File content + tenant_id: Optional tenant ID for enterprise_info + user_id: Optional user ID for user-isolated workspace + """ # Protect tasks.json from direct writes if rel_path.strip("/") == "tasks.json": return "tasks.json is read-only. Use manage_tasks tool to manage tasks." @@ -3603,6 +3757,14 @@ def _write_file(ws: Path, rel_path: str, content: str, tenant_id: str | None = N file_path = (enterprise_root / sub).resolve() if not str(file_path).startswith(str(enterprise_root)): return "Access denied for this path" + # === USER ISOLATION: Redirect user files to user directory === + elif rel_path and rel_path.startswith("workspace/") and user_id: + # User workspace files go to user-specific directory + user_root = (ws / "users" / str(user_id)).resolve() + sub = rel_path[len("workspace/"):].lstrip("/") + file_path = (user_root / sub).resolve() + if not str(file_path).startswith(str(user_root)): + return "Access denied for this path" else: file_path = (ws / rel_path).resolve() if not str(file_path).startswith(str(ws.resolve())): diff --git a/backend/app/services/channel_user_service.py b/backend/app/services/channel_user_service.py index 08a09ccac..28e623cab 100644 --- a/backend/app/services/channel_user_service.py +++ b/backend/app/services/channel_user_service.py @@ -70,11 +70,23 @@ async def resolve_channel_user( Returns: Resolved User instance """ + from app.models.channel_config import ChannelConfig + tenant_id = agent.tenant_id extra_info = extra_info or {} - # Step 1: Ensure IdentityProvider exists - provider = await self._ensure_provider(db, channel_type, tenant_id) + # Get the app_id from channel_config for this agent + channel_config_result = await db.execute( + select(ChannelConfig).where( + ChannelConfig.agent_id == agent.id, + ChannelConfig.channel_type == channel_type, + ) + ) + channel_config = channel_config_result.scalar_one_or_none() + app_id = channel_config.app_id if channel_config else None + + # Step 1: Ensure IdentityProvider exists (with app_id for precise matching) + provider = await self._ensure_provider(db, channel_type, tenant_id, app_id) # Step 2: Try to find OrgMember by external identity org_member = await self._find_org_member( @@ -170,14 +182,25 @@ async def resolve_channel_user( return user async def _ensure_provider( - self, db: AsyncSession, provider_type: str, tenant_id: uuid.UUID | None + self, db: AsyncSession, provider_type: str, tenant_id: uuid.UUID | None, app_id: str | None = None ) -> IdentityProvider: - """Get or create IdentityProvider record.""" + """Get or create IdentityProvider record. + + Args: + db: Database session + provider_type: Provider type (e.g., 'feishu', 'dingtalk') + tenant_id: Tenant ID for scoping + app_id: Optional app_id for precise matching (e.g., Feishu app_id) + """ query = select(IdentityProvider).where( IdentityProvider.provider_type == provider_type ) if tenant_id: query = query.where(IdentityProvider.tenant_id == tenant_id) + + # If app_id is provided, match precisely by app_id in config JSON + if app_id: + query = query.where(IdentityProvider.config["app_id"].astext == app_id) result = await db.execute(query) provider = result.scalar_one_or_none() @@ -187,7 +210,7 @@ async def _ensure_provider( provider_type=provider_type, name=provider_type.capitalize(), is_active=True, - config={}, + config={"app_id": app_id} if app_id else {}, tenant_id=tenant_id, ) db.add(provider) diff --git a/backend/app/services/llm/caller.py b/backend/app/services/llm/caller.py index a79378da4..057aaccb7 100644 --- a/backend/app/services/llm/caller.py +++ b/backend/app/services/llm/caller.py @@ -245,8 +245,9 @@ async def _process_tool_call( try: from app.services.vision_inject import try_inject_screenshot_vision from app.config import get_settings - ws_path = get_settings().get_agent_workspace_path(agent_id) - vision_content = try_inject_screenshot_vision(tool_name, str(result), ws_path) + from pathlib import Path + ws_path = Path(get_settings().AGENT_DATA_DIR) / str(agent_id) + vision_content = try_inject_screenshot_vision(tool_name, str(result), str(ws_path)) if vision_content: tool_content = vision_content logger.info(f"[LLM] Injected screenshot vision for {tool_name}") diff --git a/create_agent.py b/create_agent.py new file mode 100644 index 000000000..7d7cc6950 --- /dev/null +++ b/create_agent.py @@ -0,0 +1,183 @@ +#!/usr/bin/env python3 +""" +Clawith Agent Creator - Command-line tool to create agents + +Usage: + python create_agent.py --name "My Agent" --description "Agent description" --email "your@email.com" --password "your-password" + python create_agent.py --name "My Agent" --description "Agent description" --api-key "your-api-key" + python create_agent.py --help + +Environment Variables: + CLAWITH_API_KEY: Your Clawith API key (alternative to --api-key) + CLAWITH_BASE_URL: Clawith API base URL (default: http://localhost:8008) +""" + +import argparse +import json +import os +import sys + +try: + import requests +except ImportError: + print("❌ Missing dependency: requests") + print(" Install: pip install requests") + sys.exit(1) + + +def create_agent( + name: str, + description: str, + email: str = None, + password: str = None, + api_key: str = None, + base_url: str = None, + agent_type: str = "native", + personality: str = None, + boundaries: str = None, + tenant_id: str = None, +) -> dict: + """Create a new Clawith agent.""" + + base_url = base_url or os.getenv("CLAWITH_BASE_URL", "http://localhost:8000") + + # Step 1: Get API key (either from login or env) + if not api_key: + if not email or not password: + print("❌ Missing credentials. Provide either:") + print(" --api-key YOUR_API_KEY") + print(" OR --email and --password for login") + sys.exit(1) + + # Login to get API key + print(f"📝 Logging in as {email}...") + login_resp = requests.post( + f"{base_url}/api/auth/login", + json={"email": email, "password": password}, + timeout=30, + ) + + if login_resp.status_code != 200: + print(f"❌ Login failed: {login_resp.status_code}") + print(f" {login_resp.text[:200]}") + sys.exit(1) + + login_data = login_resp.json() + api_key = login_data.get("access_token") + if not api_key: + print("❌ Login succeeded but no access_token returned") + sys.exit(1) + print("✅ Login successful") + + # Step 2: Create agent + print(f"🤖 Creating agent: {name}...") + + headers = { + "Authorization": f"Bearer {api_key}", + "Content-Type": "application/json", + } + + payload = { + "name": name, + "role_description": description, + "agent_type": agent_type, + } + + if personality: + payload["personality"] = personality + + if boundaries: + payload["boundaries"] = boundaries + + if tenant_id: + payload["tenant_id"] = tenant_id + + create_resp = requests.post( + f"{base_url}/api/agents/", + headers=headers, + json=payload, + timeout=60, + ) + + if create_resp.status_code != 201: + print(f"❌ Agent creation failed: {create_resp.status_code}") + print(f" {create_resp.text[:500]}") + sys.exit(1) + + agent_data = create_resp.json() + print("✅ Agent created successfully!") + + return agent_data + + +def main(): + parser = argparse.ArgumentParser( + description="Clawith Agent Creator - Create agents via command line", + formatter_class=argparse.RawDescriptionHelpFormatter, + epilog=""" +Examples: + # Create agent with API key from environment + export CLAWITH_API_KEY=your-api-key + python create_agent.py --name "Morty" --description "A helpful assistant" + + # Create agent with login credentials + python create_agent.py --name "Morty" --description "A helpful assistant" \\ + --email "user@example.com" --password "secret" + + # Create agent with custom personality + python create_agent.py --name "JARVIS" --description "AI assistant" \\ + --personality "You are a sophisticated AI assistant." \\ + --api-key "your-api-key" + + # Create OpenClaw type agent + python create_agent.py --name "External Agent" --description "..." \\ + --agent-type "openclaw" --api-key "your-api-key" + """, + ) + + parser.add_argument("--name", required=True, help="Agent name") + parser.add_argument("--description", required=True, help="Agent role description") + parser.add_argument("--email", help="Login email (alternative to --api-key)") + parser.add_argument("--password", help="Login password (alternative to --api-key)") + parser.add_argument("--api-key", help="Clawith API key (or set CLAWITH_API_KEY env)") + parser.add_argument("--base-url", default="http://localhost:8000", help="Clawith API URL") + parser.add_argument("--agent-type", choices=["native", "openclaw"], default="native", help="Agent type") + parser.add_argument("--personality", help="Agent personality/prompt") + parser.add_argument("--boundaries", help="Agent boundaries/constraints") + parser.add_argument("--tenant-id", help="Target tenant ID (admin only)") + parser.add_argument("--json", action="store_true", dest="json_output", help="Output JSON only") + + args = parser.parse_args() + + try: + agent = create_agent( + name=args.name, + description=args.description, + email=args.email, + password=args.password, + api_key=args.api_key or os.getenv("CLAWITH_API_KEY"), + base_url=args.base_url, + agent_type=args.agent_type, + personality=args.personality, + boundaries=args.boundaries, + tenant_id=args.tenant_id, + ) + + if args.json_output: + print(json.dumps(agent, indent=2)) + else: + print("\n📋 Agent Details:") + print(f" ID: {agent.get('id')}") + print(f" Name: {agent.get('name')}") + print(f" Type: {agent.get('agent_type')}") + print(f" Status: {agent.get('status')}") + if agent.get('api_key'): + print(f" API Key: {agent.get('api_key')}") + print(f"\n🔗 Access: {args.base_url.replace('8008', '3008')}/agents/{agent.get('id')}") + except Exception as e: + print(f"❌ Error: {e}") + sys.exit(1) + + +if __name__ == "__main__": + main() diff --git a/frontend/src/components/UserWorkspace.tsx b/frontend/src/components/UserWorkspace.tsx new file mode 100644 index 000000000..30566b333 --- /dev/null +++ b/frontend/src/components/UserWorkspace.tsx @@ -0,0 +1,261 @@ +import React, { useState } from 'react'; +import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'; +import { useTranslation } from 'react-i18next'; +import { userWorkspaceApi } from '../services/userWorkspaceApi'; +import FileBrowser from '../components/FileBrowser'; +import type { FileBrowserApi } from '../components/FileBrowser'; + +interface UserWorkspaceProps { + agentId: string; + currentUserId: string; + isCreator: boolean; + isAdmin: boolean; +} + +export default function UserWorkspace({ agentId, currentUserId, isCreator, isAdmin }: UserWorkspaceProps) { + const { t } = useTranslation(); + const queryClient = useQueryClient(); + const canManage = isCreator || isAdmin; + + // Selected user (for admin/creator to view other users' workspaces) + const [selectedUserId, setSelectedUserId] = useState(currentUserId); + + // Fetch list of users from sessions (same as chat tab) + const { data: sessionsData, isLoading: sessionsLoading } = useQuery({ + queryKey: ['agent-sessions-all', agentId], + queryFn: async () => { + const token = localStorage.getItem('token'); + const res = await fetch(`/api/agents/${agentId}/sessions?scope=all`, { + headers: { Authorization: `Bearer ${token}` }, + }); + if (!res.ok) return []; + return res.json(); + }, + enabled: canManage, + }); + + // Extract unique users from sessions + const usersData = React.useMemo(() => { + if (!sessionsData || !Array.isArray(sessionsData)) return { users: [] }; + const userMap = new Map(); + sessionsData.forEach((session: any) => { + if (session.user_id) { + const userId = session.user_id; + if (!userMap.has(userId)) { + userMap.set(userId, { + id: userId, + display_name: session.username || `User ${userId.slice(0, 8)}`, + }); + } + } + }); + return { users: Array.from(userMap.values()) }; + }, [sessionsData]); + + // Fetch user's files + const { data: filesData, refetch: refetchFiles } = useQuery({ + queryKey: ['user-files', agentId, selectedUserId], + queryFn: () => userWorkspaceApi.listFiles(agentId, selectedUserId), + }); + + // Fetch user's memory + const { data: memoryData, refetch: refetchMemory } = useQuery({ + queryKey: ['user-memory', agentId, selectedUserId], + queryFn: () => userWorkspaceApi.getMemory(agentId, selectedUserId), + }); + + // Update memory mutation + const updateMemoryMutation = useMutation({ + mutationFn: ({ userId, content }: { userId: string; content: string }) => + userWorkspaceApi.updateMemory(agentId, userId, content), + onSuccess: () => { + refetchMemory(); + }, + }); + + // Memory editor state + const [memoryContent, setMemoryContent] = useState(memoryData?.content || ''); + const [isEditingMemory, setIsEditingMemory] = useState(false); + + // Sync memory content when data changes + React.useEffect(() => { + if (memoryData?.content !== undefined) { + setMemoryContent(memoryData.content); + } + }, [memoryData?.content]); + + const handleSaveMemory = async () => { + await updateMemoryMutation.mutateAsync({ + userId: selectedUserId, + content: memoryContent, + }); + setIsEditingMemory(false); + }; + + // File browser adapter for user files + const fileAdapter: any = { + list: async (path: string) => { + const res = await userWorkspaceApi.listFiles(agentId, selectedUserId, path); + return res.files.map((f: any) => ({ ...f, isDirectory: false })); + }, + read: async (path: string) => { + const content = await userWorkspaceApi.readFile(agentId, selectedUserId, path); + return { content }; + }, + write: (path: string, content: string) => userWorkspaceApi.writeFile(agentId, selectedUserId, path, content), + delete: (path: string) => userWorkspaceApi.deleteFile(agentId, selectedUserId, path), + upload: (file: File, path: string, onProgress?: (p: number) => void) => userWorkspaceApi.uploadFile(agentId, selectedUserId, file, path, onProgress), + downloadUrl: (path: string) => userWorkspaceApi.getDownloadUrl(agentId, selectedUserId, path), + }; + + // Get display name for selected user + const getUserName = (userId: string) => { + if (userId === currentUserId) { + return t('userWorkspace.myself', '我自己'); + } + const user = usersData?.users.find(u => u.id === userId); + return user?.display_name || userId; + }; + + return ( +
+ {/* Header with user selector (for admin/creator) */} +
+
+
+

{t('userWorkspace.title', '个人空间')}

+

+ {t('userWorkspace.description', '每个用户都有独立的个人空间，用于存储私有文件和记忆')} +

+
+ + {/* User selector for admin/creator */} + {canManage && ( +
+ + +
+ )} +
+ + {/* Info banner */} +
+ 💡 {t('common.tip', '提示')}: {t('userWorkspace.tip', '个人空间中的文件和记忆对该用户私有，其他用户无法访问。管理员和创建者可以查看所有用户的个人空间。')} +
+
+ + {/* Two columns: Files and Memory */} +
+ {/* Left: User Files */} +
+

+ 📁 {t('userWorkspace.myFiles', '我的文件')} +

+ +
+ + {/* Right: User Memory */} +
+
+

+ 📝 {t('userWorkspace.myMemory', '个人记忆')} +

+ +
+ + {isEditingMemory ? ( + <> +