多用户文件区隔

[lijiajun1997]

Pre-checks

• I have searched existing issues and this is not a duplicate.

What problem does this solve?

对于公司公用的数字员工，不同用户上传的文件应该自动归集在一个用户文件夹里 并且对其他用户隐藏

Proposed solution

No response

Willing to contribute?

• I'd be interested in working on this.

[Clawiee]

Hi @lijiajun1997,

Thank you for submitting this feature request! This is an important security consideration for multi-user environments.

Summary of your request:

• Automatically organize uploaded files into user-specific folders
• Ensure file isolation between different users (files hidden from other users)

This enhancement would improve data privacy and security for shared digital employee instances.

---

🙏 Friendly reminder: For better collaboration with our international contributors, please consider submitting issues in English in the future.

Our team will review this request and prioritize it accordingly. Thanks again for your feedback!

Best regards,
Clawith Team

[Clawiee]

Hi @lijiajun1997, thank you for submitting this feature request! 👍

This is a great suggestion for multi-user file isolation in shared digital employees. We understand the importance of keeping each user's files private and organized.

Friendly reminder: To help our international community better understand and collaborate on this issue, could you please provide an English translation of this issue? You can edit the issue description to add English content.

We've added this to our product backlog for consideration. Thank you for your contribution!

---

你好 @lijiajun1997，感谢提交这个功能建议！👍

这是一个很好的建议，关于在共享数字员工中实现多用户文件隔离。我们理解保持每个用户文件私密性和有序性的重要性。

友情提醒：为了帮助我们的国际社区更好地理解和协作这个 issue，能否请你提供这个 issue 的英文翻译？你可以编辑 issue 描述来添加英文内容。

我们已将其添加到产品待办列表中进行考虑。感谢你的贡献！

[lijiajun1997]

Issue: User-Level File Isolation for Shared Agents

Problem Description:

When multiple users interact with a shared company agent (public digital employee), all uploaded files are currently stored in the same workspace directory without user-level isolation. This creates privacy and data leakage concerns, as:

• User A can see/access files uploaded by User B
• No mechanism exists to segregate user data within shared agents
• Users may accidentally or intentionally view others' proprietary documents

Expected Behavior:

For shared agents accessed by multiple users within the same tenant:

• Each user's uploaded files should be automatically organized under a dedicated user directory: {agent_workspace}/workspace/users/{user_id}/
• Users should only see and access their own uploaded files
• Admin users (tenant admin) should have visibility into all user files for oversight
• File operations (upload, list, download, delete) must enforce ownership-based access control

Current Behavior:

Currently, files uploaded through /chat/upload and /agents/{agent_id}/files/upload are saved to:

• {agent_id}/workspace/uploads/ (via upload.py)
• {agent_id}/workspace/knowledge_base/ (via files.py)

All users accessing the same agent can view all files via the list API with no ownership filtering.

Proposed Solution:

Implement a multi-tiered file isolation strategy:

Phase 1: File Path Restructuring

1. Modify upload endpoints to automatically route files to user-isolated directories:

   • /agents/{agent_id}/files/upload → save to workspace/users/{user_id}/{sub_path}/
   • /chat/upload → save to workspace/users/{user_id}/uploads/
   • Optional: Allow admin to upload to shared workspace/knowledge_base/ for shared resources

2. Create File Metadata Model in backend/app/models (new file file_metadata.py):

   class FileMetadata(Base):
       __tablename__ = "file_metadata"
       id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), primary_key=True)
       agent_id: Mapped[uuid.UUID] = mapped_column(ForeignKey("agents.id"))
       user_id: Mapped[uuid.UUID] = mapped_column(ForeignKey("users.id"))
       file_path: Mapped[str] = mapped_column(String(500))
       file_name: Mapped[str] = mapped_column(String(255))
       is_shared: Mapped[bool] = mapped_column(Boolean, default=False)  # Admin flag
       created_at: Mapped[datetime] = mapped_column(...)

Phase 2: Access Control Enforcement

1. Update list_files endpoint in files.py:

   • Query FileMetadata with WHERE user_id = current_user.id OR (current_user.role == 'admin')
   • Return only user-owned files or shared files

2. Update read_file/download_file endpoints:

   • Add ownership check before serving files
   • Return 403 if user lacks access rights

3. Update delete_file endpoint:

   • Only allow deletion of own files
   • Admin can delete any file

Phase 3: Migration & Backward Compatibility

1. Data migration script for existing agents:

   • Detect non-user-partitioned files
   • Reorganize into users/{user_id}/ structure based on upload history (if available)
   • For orphaned files, assign to admin or mark as is_shared=True

2. Configuration flag to enable/disable user isolation (tenant-level setting)

Additional Context:

• Multi-tenant architecture is already implemented in tenant.py
• User model with tenant_id exists in user.py
• Agent access control via check_agent_access() already validates user-agent permissions
• Consider integrating with existing RBAC system from auth documentation

Impact:

• High: Enhances data privacy and GDPR compliance
• Medium: Requires API changes and frontend updates for file browsing UI
• Low: Backward compatible with migration script

Priority: P0 - Security/Privacy Concern @Clawiee

[wisdomqin]

Hi @lijiajun1997, thanks for the detailed proposal! We appreciate the effort you put into designing the solution.

After careful consideration, we've decided not to implement user-level file isolation within shared agents. Here's our reasoning:

Design Philosophy: Shared Agent = Shared Resources

In Clawith's architecture, a company-wide (shared) agent is designed so that all of its resources — workspace files, knowledge base, skills, and memory — are collectively owned by the agent itself, not by individual users. When you upload a file to a shared agent, the intent is for the agent to use that file to serve all users who interact with it.

If a user has sensitive or private files they don't want others to see, the correct approach is to create a personal (private) agent (scope_type = "user"). This is already fully supported — private agents are only visible to their creator, providing complete data isolation out of the box.

Architectural Complexity of User-Level File Isolation

Beyond the design philosophy, implementing this feature would introduce significant architectural problems:

1. Agent Identity vs User Identity Conflict

The agent's backend processes — heartbeat monitoring, autonomous triggers (Pulse), scheduled tasks, and tool execution — all operate as the agent, not as any specific user. If files are partitioned by user:

• Which user's files should the agent read during an autonomous trigger?
• When the agent proactively processes data via Pulse, whose uploads should it access?
• When Agent A communicates with Agent B (inter-agent collaboration), which user context applies?

There is no clean answer. The agent would need a "superuser" mode to read all files, which defeats the purpose of isolation.

2. Knowledge Base & RAG Breakage

Files uploaded to the knowledge base are indexed for retrieval-augmented generation (RAG). User-level isolation would mean:

• User A's uploaded documents can only enhance responses for User A
• The same agent would give different quality answers to different users based on who uploaded what
• This fundamentally breaks the concept of a shared knowledge worker

3. Massive API Surface Change

Every file-related endpoint (upload, list, read, download, delete) would need user-context injection. Additionally, the FileBrowser frontend component, the agent_tools.py file operations, and the agent_context.py workspace reader would all need user-aware logic — roughly 15+ files across frontend and backend.

4. Migration & Backward Compatibility Risk

Existing deployments have files in a flat structure. A migration would need to retroactively assign ownership to files with no upload history metadata, creating orphaned or misattributed files.

Recommended Alternative

For your use case, we recommend:

Scenario	Solution
Private files only I should see	Create a personal agent (scope = "Only Me")
Shared knowledge for the whole team	Upload to the shared agent's workspace/knowledge base
Temporary file for a single conversation	Use the chat upload feature (files are scoped to the session context)

This approach keeps the architecture clean while fully addressing privacy needs through agent-level isolation rather than file-level isolation within a single agent.

---

We're closing this issue as "won't fix" based on the above reasoning. If you have a specific workflow that isn't covered by the personal agent approach, please feel free to open a new discussion — we'd love to hear more about your use case!

Thanks again for the thoughtful contribution.