Compare commits

...
10 Commits
Author SHA1 Message Date
yiling 6e9cf8dfb6 Release v0.4.1 2026-08-30 20:26:57 +08:00
Yiling-J d2620f6911 fix(webui): prevent empty folder flash during initial loading (#367) 2026-08-30 18:43:23 +08:00
Yiling-J 4537baa6a2 feat(webui): redesign comment attachment display into compact rows (#366)
* feat(webui): redesign comment attachment display into compact rows

* feat(webui): support pure frontend image extension matching and self-contained preview dialog

* fix(webui): size image preview dialog to min(image size, 80% screen size)

* fix(webui): prevent horizontal overflow of comment attachment rows in scroll areas

* fix(webui): centralize attachment image preview ownership and localize download title
2026-08-30 17:16:20 +08:00
yiling 810e0c4cf5 fix(agent): only include duration_seconds for time-based media (video/audio) 2026-08-30 15:51:23 +08:00
yiling 07cb648183 fix(agent): use total_frames for video and total_pages for pdf in asset context 2026-08-30 15:44:59 +08:00
yiling c6602c9f1c docs(readme): add docker pulls, release, and license badges 2026-08-30 15:32:27 +08:00
Yiling-J 86032539ed feat(agent): refactor message context into unified shumai_message (#365)
* feat(agent): refactor message context into unified shumai_message

* fix(agent): persist custom_message entry type in DatabaseSessionStorage and handle message mapping defensively

* fix(agent): pass clean prompt to harness and replace optimistic messages on shumai_message stream

* fix(agent): align asset context DTO contract, sync comment attachments, and fix session stats
2026-08-30 15:25:13 +08:00
Yiling-J b2ec012e10 feat(webui): add manage versions option to file card context menu (#364) 2026-08-29 19:19:49 +08:00
Yiling-J 7fd8623684 fix(asset,webui): disallow dropping version stacks onto files and version stacks (#363)
* fix(asset,webui): disallow dropping version stacks onto files and version stacks

* fix(webui): derive isSingleFile from total drag selection and remove unused hasVersionStacks
2026-08-29 16:09:36 +08:00
Yiling-J 083753a96d refactor(agent): remove executeAgentToolWorkflow and invoke core services directly (#362)
* refactor(agent): remove executeAgentToolWorkflow and invoke core services directly

* fix(core): ensure creation atomicity, strict assetType filtering, and id-desc listing
2026-08-29 15:19:08 +08:00
95 changed files with 4306 additions and 2451 deletions
+6
View File
@@ -8,6 +8,12 @@
<strong>An open-source platform for all your creative work.</strong>
</p>
<p align="center">
<a href="https://hub.docker.com/r/shumaione/shumai"><img alt="Docker pulls" src="https://img.shields.io/docker/pulls/shumaione/shumai" /></a>
<a href="https://github.com/shumaiOne/shumai/releases"><img alt="GitHub latest release" src="https://img.shields.io/github/v/release/shumaiOne/shumai" /></a>
<a href="LICENSE"><img alt="License" src="https://img.shields.io/badge/license-MIT-blue" /></a>
</p>
<p align="center">
<a target="_blank" href="https://shumai.one/">Website</a> | <a target="_blank" href="https://docs.shumai.one/getting-started/overview">Docs</a> | <a target="_blank" href="https://staging.shumai.one">Demo</a> | <a target="_blank" href="https://discord.gg/sUzhujK6DD">Discord</a> | <a target="_blank" href="README_CN.md">中文</a>
</p>
+6 -1
View File
@@ -9,8 +9,13 @@
</p>
<p align="center">
<a target="_blank" href="https://shumai.one/">官方网站</a> | <a target="_blank" href="https://docs.shumai.one/getting-started/overview">文档</a> | <a target="_blank" href="https://staging.shumai.one">在线演示</a> | <a target="_blank" href="README.md">English</a>
<a href="https://hub.docker.com/r/shumaione/shumai"><img alt="Docker pulls" src="https://img.shields.io/docker/pulls/shumaione/shumai" /></a>
<a href="https://github.com/shumaiOne/shumai/releases"><img alt="GitHub latest release" src="https://img.shields.io/github/v/release/shumaiOne/shumai" /></a>
<a href="LICENSE"><img alt="License" src="https://img.shields.io/badge/license-MIT-blue" /></a>
</p>
<p align="center">
<a target="_blank" href="https://shumai.one/">官方网站</a> | <a target="_blank" href="https://docs.shumai.one/getting-started/overview">文档</a> | <a target="_blank" href="https://staging.shumai.one">在线演示</a> | <a target="_blank" href="README.md">English</a>
</p>
![Shumai 应用截图](docs/screenshot.webp)
+1 -1
View File
@@ -1,6 +1,6 @@
{
"name": "@shumai/agent-app",
"version": "0.4.0",
"version": "0.4.1",
"private": true,
"type": "module",
"bin": {
-1
View File
@@ -1,5 +1,4 @@
export * from '@shumai/agent/src/workflows/agent-autofill'
export * from '@shumai/agent/src/workflows/agent-chat'
export * from '@shumai/agent/src/workflows/agent-embedding'
export * from '@shumai/agent/src/workflows/agent-tool-call'
export * from '@shumai/agent/src/workflows/query-embedding-for-search'
+1 -1
View File
@@ -1,6 +1,6 @@
{
"name": "@shumai/cli",
"version": "0.4.0",
"version": "0.4.1",
"private": true,
"type": "module",
"bin": {
+1 -1
View File
@@ -1,6 +1,6 @@
{
"name": "@shumai/transcode-app",
"version": "0.4.0",
"version": "0.4.1",
"private": true,
"type": "module",
"bin": {
+1 -1
View File
@@ -1,6 +1,6 @@
{
"name": "@shumai/web-app",
"version": "0.4.0",
"version": "0.4.1",
"private": true,
"type": "module",
"dependencies": {
+1 -1
View File
@@ -1,6 +1,6 @@
{
"name": "shumai",
"version": "0.4.0",
"version": "0.4.1",
"private": true,
"type": "module",
"repository": {
+1 -1
View File
@@ -1,6 +1,6 @@
{
"name": "@shumai/agent",
"version": "0.4.0",
"version": "0.4.1",
"private": true,
"type": "module",
"main": "./src/index.ts",
+42 -562
View File
@@ -13,8 +13,8 @@ import {
getCommentActivity,
getProjectAutofillFieldsActivity,
updateAssetMetadataActivity,
getAssetPathHierarchyActivity,
getAssetPathContextActivity,
executeAgentToolActivity,
generateSessionNameActivity,
type GenerateSessionNameParams,
getUserTeamInfoActivity,
@@ -36,8 +36,6 @@ import {
type Asset,
} from '@shumai/db'
import { setupTestDbHooks } from '@shumai/db/test'
import { authzService } from '@shumai/core/src/authz/authz'
import { uploadService } from '@shumai/core/src/upload/upload'
vi.mock('../index', async () => {
const actual = await vi.importActual('../index')
@@ -567,8 +565,18 @@ describe('Agent Database Activities Integration', () => {
describe('initializeAgentSessionActivity', () => {
it('should initialize a session, create agent/user records if missing, and store existing comments context', async () => {
const attAsset = await prisma.asset.create({
data: {
name: 'attached-doc.pdf',
type: AssetType.file,
mediaType: 'application/pdf',
status: AssetStatus.uploaded,
projectId: project.id,
},
})
// Create first comment so it acts as context
await prisma.assetComment.create({
const firstComment = await prisma.assetComment.create({
data: {
assetId: asset.id,
message: 'Hello <@' + user.id + '> check this',
@@ -576,6 +584,13 @@ describe('Agent Database Activities Integration', () => {
},
})
await prisma.assetCommentAttachment.create({
data: {
commentId: firstComment.id,
assetId: attAsset.id,
},
})
await sleep(2)
// Create second comment that user responds with, triggering session initialization
const userComment = await prisma.assetComment.create({
@@ -614,9 +629,20 @@ describe('Agent Database Activities Integration', () => {
// eslint-disable-next-line @typescript-eslint/no-explicit-any -- entry data is stored as Json in DB and needs casting to check properties
const parsedEntry = pathEntries[0] as any
expect(parsedEntry.message.content[0].text).toContain(
`[${user.name} (owner)]: Hello <@${user.name}> check this`,
)
expect(parsedEntry.type).toBe('custom_message')
expect(parsedEntry.customType).toBe('shumai_message')
expect(parsedEntry.content).toContain(`Hello <@${user.name}> check this`)
expect(parsedEntry.details.user.name).toBe(user.name)
expect(parsedEntry.details.user.role).toBe('owner')
expect(parsedEntry.details.attachedFiles).toEqual([
{
id: attAsset.id,
name: 'attached-doc.pdf',
type: 'file',
mediaType: undefined,
mimeType: 'application/pdf',
},
])
})
it('should distinguish Main Session (userCommentId: null) and Thread Session (userCommentId: rootId) during lazy sync', async () => {
@@ -730,7 +756,7 @@ describe('Agent Database Activities Integration', () => {
const msg3Entry = pathEntries.find((e) => e.id.includes(msg3.id))
expect(msg3Entry).toBeDefined()
// eslint-disable-next-line @typescript-eslint/no-explicit-any
const text = (msg3Entry as any).message.content[0].text
const text = (msg3Entry as any).content ?? (msg3Entry as any).message?.content[0]?.text
expect(text).toContain(`[Thread ID: ${msg3.id}] [Replies: 1]`)
})
@@ -1343,10 +1369,14 @@ describe('Agent Database Activities Integration', () => {
})
const pathCtx = await getAssetPathContextActivity(targetAsset.id)
expect(pathCtx).toContain('Path: RootFolder/SubFolder/TargetImage.webp')
expect(pathCtx).toContain(`name: RootFolder, id: ${rootFolder.id}`)
expect(pathCtx).toContain(`name: SubFolder, id: ${subfolder.id}`)
expect(pathCtx).toContain(`name: TargetImage.webp, id: ${targetAsset.id}`)
expect(pathCtx).toBe('RootFolder/SubFolder/TargetImage.webp')
const hierarchy = await getAssetPathHierarchyActivity(targetAsset.id)
expect(hierarchy.path).toBe('RootFolder/SubFolder/TargetImage.webp')
expect(hierarchy.ancestors).toEqual([
{ id: rootFolder.id, name: 'RootFolder' },
{ id: subfolder.id, name: 'SubFolder' },
])
})
})
@@ -1378,556 +1408,6 @@ describe('Agent Database Activities Integration', () => {
})
})
describe('executeAgentToolActivity', () => {
beforeEach(() => {
vi.spyOn(authzService, 'hasPermission').mockResolvedValue()
vi.spyOn(uploadService, 'triggerPostUploadWorkflows').mockResolvedValue()
})
describe('list_assets', () => {
it('should list assets inside a folder with cursor pagination', async () => {
const folder = await prisma.asset.create({
data: {
name: 'WorkspaceFolder',
type: AssetType.folder,
status: AssetStatus.uploaded,
projectId: project.id,
},
})
await prisma.asset.create({
data: {
name: 'file1.txt',
type: AssetType.file,
status: AssetStatus.uploaded,
projectId: project.id,
parentId: folder.id,
},
})
await prisma.asset.create({
data: {
name: 'subfolder1',
type: AssetType.folder,
status: AssetStatus.uploaded,
projectId: project.id,
parentId: folder.id,
},
})
const res = await executeAgentToolActivity({
taskId: 'task-1',
toolName: 'list_assets',
args: { parent: folder.id, page: 1, pageSize: 1 },
userId: user.id,
})
expect(res.assets.length).toBe(1)
expect(res.pageInfo.cursor).toBeDefined()
})
it('should resolve version_stack name and size from top child version when container name is empty', async () => {
const folder = await prisma.asset.create({
data: {
name: 'WorkspaceFolder',
type: AssetType.folder,
status: AssetStatus.uploaded,
projectId: project.id,
},
})
const versionStack = await prisma.asset.create({
data: {
name: '',
type: AssetType.version_stack,
status: AssetStatus.uploaded,
projectId: project.id,
parentId: folder.id,
},
})
await prisma.asset.create({
data: {
name: 'banana_ghost.txt',
type: AssetType.file,
status: AssetStatus.uploaded,
projectId: project.id,
parentId: versionStack.id,
sizeByte: 622960,
sortIndex: '0|i00000:',
},
})
const res = await executeAgentToolActivity({
taskId: 'task-1',
toolName: 'list_assets',
args: { parent: folder.id, page: 1, pageSize: 10 },
userId: user.id,
})
const stackItem = res.assets.find(
(a: { id: string; name: string; size: number; type: string }) => a.id === versionStack.id,
)
expect(stackItem).toBeDefined()
expect(stackItem?.name).toBe('banana_ghost.txt')
expect(stackItem?.size).toBe(622960)
expect(stackItem?.type).toBe('version_stack')
})
})
describe('create_folder', () => {
it('should create folder and increment parent fileCount', async () => {
const folder = await prisma.asset.create({
data: {
name: 'WorkspaceFolder',
type: AssetType.folder,
status: AssetStatus.uploaded,
projectId: project.id,
fileCount: 0,
},
})
const res = await executeAgentToolActivity({
taskId: 'task-1',
toolName: 'create_folder',
args: { parent: folder.id, name: 'subfolder' },
userId: user.id,
})
expect(res.name).toBe('subfolder')
expect(res.type).toBe('folder')
const parentFolder = await prisma.asset.findUnique({ where: { id: folder.id } })
expect(parentFolder?.fileCount).toBe(1)
})
})
describe('create_file', () => {
it('should create file, increment parent fileCount, and update parent sizes', async () => {
const folder = await prisma.asset.create({
data: {
name: 'WorkspaceFolder',
type: AssetType.folder,
status: AssetStatus.uploaded,
projectId: project.id,
fileCount: 0,
sizeByte: 0,
},
})
const res = await executeAgentToolActivity({
taskId: 'task-1',
toolName: 'create_file',
args: {
parent: folder.id,
s3Key: 'uploads/testfile.txt',
name: 'testfile.txt',
size: 500,
contentType: 'text/plain',
},
userId: user.id,
})
expect(res.name).toBe('testfile.txt')
expect(res.size).toBe(500)
const parentFolder = await prisma.asset.findUnique({ where: { id: folder.id } })
expect(parentFolder?.fileCount).toBe(1)
expect(Number(parentFolder?.sizeByte)).toBe(500)
expect(uploadService.triggerPostUploadWorkflows).toHaveBeenCalled()
})
it('should persist metadata on the created file when metadata map is provided', async () => {
await prisma.metadataField.create({
data: {
key: 'prompt',
scope: 'PROJECT',
projectId: project.id,
teamId: team.id,
config: { name: 'Prompt', type: 'text', autofillSource: 'CREATION_CONTEXT' },
},
})
const folder = await prisma.asset.create({
data: {
name: 'WorkspaceFolder',
type: AssetType.folder,
status: AssetStatus.uploaded,
projectId: project.id,
fileCount: 0,
sizeByte: 0,
},
})
const res = await executeAgentToolActivity({
taskId: 'task-1',
toolName: 'create_file',
args: {
parent: folder.id,
s3Key: 'uploads/ctx.txt',
name: 'ctx.txt',
size: 100,
contentType: 'text/plain',
metadata: { prompt: 'Generated using gemini' },
},
userId: user.id,
})
const val = await prisma.assetMetadataValue.findFirst({
where: { assetId: res.id, fieldKey: 'prompt' },
})
expect(val?.stringValue).toBe('Generated using gemini')
})
it('should persist select and selectMulti metadata with dynamic newOption', async () => {
const selectField = await prisma.metadataField.create({
data: {
key: 'provider',
scope: 'PROJECT',
project: { connect: { id: project.id } },
config: {
name: 'Provider',
type: 'select',
autofillSource: 'CREATION_CONTEXT',
select: { options: [{ id: 'openai', displayName: 'OpenAI', color: '#f43f5e' }] },
},
},
})
const multiField = await prisma.metadataField.create({
data: {
key: 'tags',
scope: 'PROJECT',
project: { connect: { id: project.id } },
config: {
name: 'Tags',
type: 'selectMulti',
autofillSource: 'CREATION_CONTEXT',
selectMulti: { options: [{ id: 'tag1', displayName: 'Tag 1', color: '#3b82f6' }] },
},
},
})
const folder = await prisma.asset.create({
data: {
name: 'WorkspaceFolder',
type: AssetType.folder,
status: AssetStatus.uploaded,
projectId: project.id,
fileCount: 0,
sizeByte: 0,
},
})
const res = await executeAgentToolActivity({
taskId: 'task-1',
toolName: 'create_file',
args: {
parent: folder.id,
s3Key: 'uploads/new_opt.txt',
name: 'new_opt.txt',
size: 100,
contentType: 'text/plain',
metadata: {
provider: { newOption: { value: 'Kling' } },
tags: ['tag1', { newOption: { value: 'Tag 2' } }],
},
},
userId: user.id,
})
// Verify select field
const providerVal = await prisma.assetMetadataValue.findFirst({
where: { assetId: res.id, fieldKey: selectField.key },
})
expect(providerVal?.stringValue).toBe('kling')
// Verify select field config was updated with new option
const updatedSelectField = await prisma.metadataField.findUnique({
where: { key: selectField.key },
})
const selectOpts =
(updatedSelectField?.config as PrismaJson.FieldConfig)?.select?.options || []
expect(selectOpts.some((o) => o.displayName === 'Kling' && o.id === 'kling')).toBe(true)
// Verify selectMulti field
const tagsVal = await prisma.assetMetadataValue.findFirst({
where: { assetId: res.id, fieldKey: multiField.key },
})
expect(tagsVal?.jsonValue).toEqual(['tag1', 'tag-2'])
// Verify selectMulti field config was updated with new option
const updatedMultiField = await prisma.metadataField.findUnique({
where: { key: multiField.key },
})
const multiOpts =
(updatedMultiField?.config as PrismaJson.FieldConfig)?.selectMulti?.options || []
expect(multiOpts.some((o) => o.displayName === 'Tag 2' && o.id === 'tag-2')).toBe(true)
})
it('should reject metadata with keys that are not valid in this project', async () => {
const folder = await prisma.asset.create({
data: {
name: 'WorkspaceFolder',
type: AssetType.folder,
status: AssetStatus.uploaded,
projectId: project.id,
fileCount: 0,
sizeByte: 0,
},
})
await expect(
executeAgentToolActivity({
taskId: 'task-1',
toolName: 'create_file',
args: {
parent: folder.id,
s3Key: 'uploads/ctx.txt',
name: 'ctx.txt',
size: 100,
contentType: 'text/plain',
metadata: { prompt: 'ok', unknownKey: 'not allowed' },
},
userId: user.id,
}),
).rejects.toThrow(/not valid in this project/)
// No metadata value should have been written for the unknown key
const val = await prisma.assetMetadataValue.findFirst({
where: { fieldKey: 'unknownKey' },
})
expect(val).toBeNull()
})
})
describe('create_version', () => {
it('should create a version stack when parent is a regular file', async () => {
const folder = await prisma.asset.create({
data: {
name: 'WorkspaceFolder',
type: AssetType.folder,
status: AssetStatus.uploaded,
projectId: project.id,
fileCount: 1,
sizeByte: 200,
},
})
const fileAsset = await prisma.asset.create({
data: {
name: 'v1.txt',
type: AssetType.file,
status: AssetStatus.uploaded,
projectId: project.id,
parentId: folder.id,
sizeByte: 200,
},
})
const res = await executeAgentToolActivity({
taskId: 'task-1',
toolName: 'create_version',
args: {
parent: fileAsset.id,
s3Key: 'uploads/v2.txt',
name: 'v2.txt',
size: 300,
contentType: 'text/plain',
},
userId: user.id,
})
expect(res.name).toBe('v2.txt')
expect(res.size).toBe(300)
// Check version stack was created
const stack = await prisma.asset.findFirst({
where: { type: AssetType.version_stack, projectId: project.id },
include: { children: true },
})
expect(stack).not.toBeNull()
expect(stack?.children.length).toBe(2) // v1.txt and v2.txt should both be inside the stack
})
it('should add to version stack when parent is already inside a version stack', async () => {
const folder = await prisma.asset.create({
data: {
name: 'WorkspaceFolder',
type: AssetType.folder,
status: AssetStatus.uploaded,
projectId: project.id,
},
})
const stack = await prisma.asset.create({
data: {
name: 'VersionStack',
type: AssetType.version_stack,
status: AssetStatus.uploaded,
projectId: project.id,
parentId: folder.id,
fileCount: 1,
sizeByte: 100,
},
})
const existingFileVersion = await prisma.asset.create({
data: {
name: 'v1.txt',
type: AssetType.file,
status: AssetStatus.uploaded,
projectId: project.id,
parentId: stack.id,
sizeByte: 100,
},
})
const res = await executeAgentToolActivity({
taskId: 'task-1',
toolName: 'create_version',
args: {
parent: existingFileVersion.id,
s3Key: 'uploads/v2.txt',
name: 'v2.txt',
size: 250,
contentType: 'text/plain',
},
userId: user.id,
})
expect(res.name).toBe('v2.txt')
const updatedStack = await prisma.asset.findUnique({
where: { id: stack.id },
include: { children: true },
})
expect(updatedStack?.fileCount).toBe(2)
expect(Number(updatedStack?.sizeByte)).toBe(350)
})
it('should persist metadata on the created version when metadata map is provided', async () => {
await prisma.metadataField.create({
data: {
key: 'prompt',
scope: 'PROJECT',
projectId: project.id,
teamId: team.id,
config: { name: 'Prompt', type: 'text', autofillSource: 'CREATION_CONTEXT' },
},
})
const folder = await prisma.asset.create({
data: {
name: 'WorkspaceFolder',
type: AssetType.folder,
status: AssetStatus.uploaded,
projectId: project.id,
fileCount: 1,
sizeByte: 200,
},
})
const fileAsset = await prisma.asset.create({
data: {
name: 'v1.txt',
type: AssetType.file,
status: AssetStatus.uploaded,
projectId: project.id,
parentId: folder.id,
sizeByte: 200,
},
})
const res = await executeAgentToolActivity({
taskId: 'task-1',
toolName: 'create_version',
args: {
parent: fileAsset.id,
s3Key: 'uploads/v2.txt',
name: 'v2.txt',
size: 300,
contentType: 'text/plain',
metadata: { prompt: 'Generated using seedance' },
},
userId: user.id,
})
const val = await prisma.assetMetadataValue.findFirst({
where: { assetId: res.id, fieldKey: 'prompt' },
})
expect(val?.stringValue).toBe('Generated using seedance')
})
it('should persist select and selectMulti newOption metadata in create_version', async () => {
const selectField = await prisma.metadataField.create({
data: {
key: 'versionProvider',
scope: 'PROJECT',
project: { connect: { id: project.id } },
config: {
name: 'Version Provider',
type: 'select',
autofillSource: 'CREATION_CONTEXT',
select: { options: [{ id: 'openai', displayName: 'OpenAI', color: '#f43f5e' }] },
},
},
})
const folder = await prisma.asset.create({
data: {
name: 'WorkspaceFolder',
type: AssetType.folder,
status: AssetStatus.uploaded,
projectId: project.id,
fileCount: 1,
sizeByte: 200,
},
})
const fileAsset = await prisma.asset.create({
data: {
name: 'v1.txt',
type: AssetType.file,
status: AssetStatus.uploaded,
projectId: project.id,
parentId: folder.id,
sizeByte: 200,
},
})
const res = await executeAgentToolActivity({
taskId: 'task-1',
toolName: 'create_version',
args: {
parent: fileAsset.id,
s3Key: 'uploads/v2.txt',
name: 'v2.txt',
size: 300,
contentType: 'text/plain',
metadata: {
versionProvider: { newOption: { value: 'Midjourney' } },
},
},
userId: user.id,
})
const val = await prisma.assetMetadataValue.findFirst({
where: { assetId: res.id, fieldKey: selectField.key },
})
expect(val?.stringValue).toBe('midjourney')
const updatedField = await prisma.metadataField.findUnique({
where: { key: selectField.key },
})
const opts = (updatedField?.config as PrismaJson.FieldConfig)?.select?.options || []
expect(opts.some((o) => o.displayName === 'Midjourney' && o.id === 'midjourney')).toBe(true)
})
})
})
describe('generateSessionNameActivity', () => {
it('should generate and save session name for chat sessions', async () => {
await prisma.team.create({
+129 -561
View File
@@ -1,29 +1,15 @@
import {
type AgentMessage,
type AgentTool,
type SessionTreeEntry,
} from '@earendil-works/pi-agent-core'
import { type AgentMessage, type AgentTool } from '@earendil-works/pi-agent-core'
import { type ImageContent } from '@earendil-works/pi-ai'
import { assetService } from '@shumai/core/src/asset/asset'
import {
authzService,
Permission,
ResourceType,
resolveEffectiveRole,
} from '@shumai/core/src/authz/authz'
import { resolveEffectiveRole } from '@shumai/core/src/authz/authz'
import { logger } from '@shumai/core/src/logger'
import { mcpService } from '@shumai/core/src/mcp/mcp-service'
import { metadataService } from '@shumai/core/src/metadata/metadata'
import { encodeCursor, paginateQuery } from '@shumai/core/src/pagination'
import { s3Service } from '@shumai/core/src/s3/s3'
import { uploadService } from '@shumai/core/src/upload/upload'
import { VersionStackService } from '@shumai/core/src/versionStack/versionStack'
import { getAgentRequiredLevel, getRoleLevel } from '@shumai/core/src/agent/permissions'
import { AssetType, prisma, Prisma, type Skill } from '@shumai/db'
import { registerLocalCancelHandler, unregisterLocalCancelHandler } from '@shumai/workflow-core'
import { ApplicationFailure, Context } from '@temporalio/activity'
import { generateKeyBetween } from 'jittered-fractional-indexing'
import { ulid } from 'ulid'
import { DatabaseSessionStorage } from '../database-session-storage'
import {
createAgentSession,
@@ -34,7 +20,11 @@ import {
import { aiUsageService } from '@shumai/core/src/ai-usage/ai-usage'
import { quotaService, QuotaExceededError } from '@shumai/core/src/quota/quota-service'
import { UpdateAssetMetadataRequest } from '@shumai/dtos'
import {
UpdateAssetMetadataRequest,
type ShumaiMessageContext,
type ShumaiMediaPosition,
} from '@shumai/dtos'
export interface Usage {
inputTokens: number
@@ -90,7 +80,7 @@ async function executeAgentPrompt(params: {
agentId: string
prompt: string
images: string[]
agentsInstruction: string
messageContext?: ShumaiMessageContext
sessionId?: string
userId?: string
projectId?: string
@@ -125,15 +115,15 @@ shumai has its own cloud file system. If a user asks you to perform file system
If you need to create files in the local filesystem (for example, a temporary file for uploading), only the '.pi' folder in the current directory has write permissions. Do NOT attempt to create files in any other directories.
When creating a file or version, you may attach metadata (for example, the AI model or prompt used to generate the asset). The allowed field keys and value types are declared directly in the 'metadata' parameter of the 'create_file' and 'create_version' tools.`
When creating a file or version, you may attach metadata (for example, the AI model or prompt used to generate the asset). The allowed field keys and value types are declared directly in the 'metadata' parameter of the 'create_file' and 'create_version' tools.
# Message Context & Tools
User messages may contain a <context> block detailing the user, active asset location, playback position, and attachments. Use the asset IDs from <context> when invoking tools (e.g. 'analyze_image', 'screenshot', 'read_pdf_pages', 'download_asset', 'list_assets'). When an <annotation /> tag is present, it indicates the user has drawn visual markups on the asset at the specified position.`
if (agent.soul) {
systemPrompt = `${systemPrompt}\n\nAgent Personality and Core Instructions:\n${agent.soul}`
}
// Note: params.agentsInstruction is no longer appended to systemPrompt here.
// Instead, it is persisted as a custom message session entry in the conversation history below.
let targetAssetId = params.assetId
if (!targetAssetId) {
if (params.userCommentId) {
@@ -264,32 +254,9 @@ When creating a file or version, you may attach metadata (for example, the AI mo
}
try {
if (params.agentsInstruction && params.agentsInstruction.trim()) {
const storage = session.getStorage()
const parentId = await storage.getLeafId()
await storage.appendEntry({
id: ulid(),
type: 'custom_message',
parentId,
timestamp: new Date().toISOString(),
customType: 'context',
content: params.agentsInstruction.trim(),
} as unknown as SessionTreeEntry)
}
if (params.attachedAssets && params.attachedAssets.length > 0) {
const storage = session.getStorage()
const parentId = await storage.getLeafId()
await storage.appendEntry({
id: ulid(),
type: 'custom',
parentId,
timestamp: new Date().toISOString(),
customType: 'context_display_info',
data: {
assets: params.attachedAssets,
},
} as unknown as SessionTreeEntry)
const storage = session.getStorage()
if (storage instanceof DatabaseSessionStorage && params.messageContext) {
storage.currentMessageContext = params.messageContext
}
let totalInputTokens = 0
@@ -423,7 +390,7 @@ When creating a file or version, you may attach metadata (for example, the AI mo
const sessionEntries = await session.getEntries()
sessionEntries.forEach((entry) => {
if (entry.type === 'message') {
if (entry.type === 'message' && entry.message) {
const msg = entry.message
if (msg.role === 'toolResult') {
const logMsg = { ...msg, content: undefined }
@@ -460,7 +427,6 @@ When creating a file or version, you may attach metadata (for example, the AI mo
cost: totalCost,
}
const storage = session.getStorage()
let sessionId = ''
if (storage instanceof DatabaseSessionStorage) {
sessionId = storage.sessionId
@@ -488,11 +454,11 @@ export interface AgentChatParams {
projectId: string
folderId: string
assetId?: string
agentsInstruction?: string
sessionId: string
userId?: string
userCommentId?: string | null
context: AgentExecutionContext
messageContext?: ShumaiMessageContext
attachedAssets?: Array<{ id: string; name: string; type: string }>
}
@@ -522,40 +488,19 @@ export async function agentChatActivity(params: AgentChatParams) {
const cleanMessage = params.message.replace(/<@[A-Z0-9]+>/g, '').trim()
const sessionId = params.sessionId
let prompt = cleanMessage
if (params.userCommentId) {
let targetUserId = params.userId
if (!targetUserId) {
const comment = await prisma.assetComment.findUnique({
where: { id: params.userCommentId },
select: { creatorId: true },
})
targetUserId = comment?.creatorId || undefined
}
if (targetUserId) {
const userInfo = await getUserTeamInfoActivity({
userId: targetUserId,
teamId: params.teamId,
})
if (userInfo) {
prompt = `[${userInfo.name} (${userInfo.role})]: ${cleanMessage}`
}
}
}
return executeAgentPrompt({
taskId: params.taskId,
teamId: params.teamId,
agentId: params.agentId,
prompt,
prompt: cleanMessage,
images: params.imageUrls,
agentsInstruction: params.agentsInstruction || '',
sessionId,
userId: params.userId,
projectId: params.projectId,
assetId: params.assetId || params.folderId,
userCommentId: params.userCommentId,
context: params.context,
messageContext: params.messageContext,
attachedAssets: params.attachedAssets,
})
}
@@ -597,7 +542,6 @@ export async function autofillAiActivity(params: AutofillAiParams) {
agentId: agent.id,
prompt: fullPrompt,
images: params.images,
agentsInstruction: '',
sessionId: undefined,
userId: undefined,
projectId: params.projectId,
@@ -720,7 +664,10 @@ export async function initializeAgentSessionActivity(params: {
createdAt: { lte: rootComment.createdAt },
},
orderBy: { id: 'asc' },
include: { creator: true },
include: {
creator: true,
attachments: { include: { asset: true } },
},
})
// 2. Fetch thread replies up to userComment.createdAt excluding userComment itself
@@ -732,7 +679,10 @@ export async function initializeAgentSessionActivity(params: {
id: { not: userComment.id },
},
orderBy: { id: 'asc' },
include: { creator: true },
include: {
creator: true,
attachments: { include: { asset: true } },
},
})
: []
@@ -782,7 +732,13 @@ export async function initializeAgentSessionActivity(params: {
}
}
function formatCommentMessage(c: (typeof allCommentsToSync)[0]): string {
const assetRecord = await prisma.asset.findUnique({
where: { id: userComment.assetId },
select: { media: true },
})
const proxyType = (assetRecord?.media as PrismaJson.MediaInfo | null)?.proxyType
function buildCommentEntry(c: (typeof allCommentsToSync)[0]) {
const isAgent = c.creator?.type === 'agent' || c.sessionId !== null
let messageContent = c.message || ''
@@ -792,13 +748,82 @@ export async function initializeAgentSessionActivity(params: {
})
if (isAgent) {
const agentName = c.creator?.name || 'Ai Agent'
return `[Agent Message][${agentName}]: ${messageContent}`
} else if (c.creator?.name) {
const message: AgentMessage = {
role: 'assistant',
content: [{ type: 'text', text: messageContent }],
api: 'custom',
provider: 'shumai',
model: 'agent',
usage: {
input: 0,
output: 0,
cacheRead: 0,
cacheWrite: 0,
totalTokens: 0,
cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
},
stopReason: 'stop',
timestamp: c.createdAt.getTime(),
}
return {
type: 'message' as const,
data: { message },
}
}
let userObj: ShumaiMessageContext['user'] = undefined
if (c.creator) {
const role = (c.creatorId ? userRoleMap.get(c.creatorId) : undefined) || 'user'
return `[${c.creator.name} (${role})]: ${messageContent}`
userObj = {
id: c.creator.id,
name: c.creator.name || 'Unknown',
role,
}
}
let position: ShumaiMediaPosition | undefined = undefined
if (c.second !== null && c.second !== undefined) {
if (proxyType === 'pdf') {
position = { type: 'page', page: Math.round(c.second) }
} else {
position = { type: 'time', seconds: c.second }
}
}
const annotation = !!(c.annotation && Array.isArray(c.annotation) && c.annotation.length > 0)
const attachedFiles: ShumaiMessageContext['attachedFiles'] = []
if (c.attachments && c.attachments.length > 0) {
for (const att of c.attachments) {
if (att.asset) {
const attProxyType = (att.asset.media as PrismaJson.MediaInfo | null)?.proxyType
attachedFiles.push({
id: att.asset.id,
name: att.asset.name,
type: att.asset.type,
mediaType: attProxyType as 'image' | 'video' | 'pdf' | 'audio' | 'other' | undefined,
mimeType: att.asset.mediaType || undefined,
})
}
}
}
const commentDetails: ShumaiMessageContext = {
...(userObj ? { user: userObj } : {}),
...(position ? { position } : {}),
...(annotation ? { annotation: true } : {}),
...(attachedFiles.length > 0 ? { attachedFiles } : {}),
}
return {
type: 'custom_message' as const,
data: {
customType: 'shumai_message',
content: messageContent,
display: true,
details: commentDetails,
},
}
return messageContent
}
// 3. Sync top-level comments into agent_session_entries (DAG spine)
@@ -810,21 +835,16 @@ export async function initializeAgentSessionActivity(params: {
})
if (!existingEntry) {
const messageContent = formatCommentMessage(c)
const message: AgentMessage = {
role: 'user',
content: [{ type: 'text', text: messageContent }],
timestamp: c.createdAt.getTime(),
}
const entryData = buildCommentEntry(c)
await prisma.agentSessionEntry.create({
data: {
id: c.id,
sessionId: mainSession.id,
assetId: userComment.assetId,
type: 'message',
type: entryData.type,
parentId: mainPrevId,
createdAt: c.createdAt,
data: { message },
data: entryData.data as PrismaJson.PiSessionEntryData,
},
})
}
@@ -850,21 +870,16 @@ export async function initializeAgentSessionActivity(params: {
})
if (!existingReplyEntry) {
const messageContent = formatCommentMessage(reply)
const message: AgentMessage = {
role: 'user',
content: [{ type: 'text', text: messageContent }],
timestamp: reply.createdAt.getTime(),
}
const entryData = buildCommentEntry(reply)
await prisma.agentSessionEntry.create({
data: {
id: reply.id,
sessionId: session.id,
assetId: userComment.assetId,
type: 'message',
type: entryData.type,
parentId: lastReplyParentId,
createdAt: reply.createdAt,
data: { message },
data: entryData.data as PrismaJson.PiSessionEntryData,
},
})
}
@@ -1203,7 +1218,11 @@ export async function getAssetActivity(assetId: string) {
export async function getCommentActivity(commentId: string) {
return prisma.assetComment.findUnique({
where: { id: commentId },
include: { attachments: { include: { asset: { include: { storageKey: true } } } } },
include: {
attachments: {
include: { asset: { include: { storageKey: true } } },
},
},
})
}
@@ -1219,7 +1238,9 @@ export async function updateAssetMetadataActivity(params: {
return metadataService.updateAssetMetadata(params.assetId, params.metadata)
}
export async function getAssetPathContextActivity(assetId: string): Promise<string> {
export async function getAssetPathHierarchyActivity(
assetId: string,
): Promise<{ path: string; ancestors: Array<{ id: string; name: string }> }> {
const parts: { name: string; id: string }[] = []
let currentId: string | null = assetId
@@ -1238,469 +1259,16 @@ export async function getAssetPathContextActivity(assetId: string): Promise<stri
currentId = assetNode.parentId
}
if (parts.length === 0) return ''
if (parts.length === 0) return { path: '', ancestors: [] }
const pathStr = parts.map((p) => p.name).join('/')
let contextStr = `Path: ${pathStr}\n\n`
for (const part of parts) {
contextStr += `name: ${part.name}, id: ${part.id}\n`
}
return contextStr
const path = parts.map((p) => p.name).join('/')
const ancestors = parts.slice(0, -1)
return { path, ancestors }
}
export interface ExecuteAgentToolParams {
taskId: string
toolName: string
// args are dynamic JSON arguments passed from the agent harness at runtime
// eslint-disable-next-line @typescript-eslint/no-explicit-any
args: any
userId?: string
}
/**
* Validates that every metadata key provided by the agent is a defined
* CREATION_CONTEXT field of the project. Unknown keys are rejected with a
* non-retryable failure so Temporal does not retry expected validation errors.
*/
async function validateCreationContextMetadata(
userId: string,
projectId: string,
metadata: Record<string, unknown> | undefined,
): Promise<void> {
if (!metadata || Object.keys(metadata).length === 0) return
const fields = await metadataService.listProjectFields(userId, projectId)
const allowedKeys = new Set(
fields
.filter((f) => f.field.config?.autofillSource === 'CREATION_CONTEXT')
.map((f) => f.field.key),
)
const invalidKeys = Object.keys(metadata).filter((key) => !allowedKeys.has(key))
if (invalidKeys.length > 0) {
throw ApplicationFailure.create({
message:
`metadata contains keys that are not valid in this project: ${invalidKeys.join(', ')}. ` +
"The valid metadata fields are fixed to the current conversation's project. " +
'If the target folder or file belongs to a different project, call the tool WITHOUT the metadata parameter.',
nonRetryable: true,
})
}
}
// eslint-disable-next-line @typescript-eslint/no-explicit-any -- Activity return type is a union of tool result shapes
export async function executeAgentToolActivity(params: ExecuteAgentToolParams): Promise<any> {
const { toolName, args, userId } = params
if (!userId) {
throw ApplicationFailure.create({
message: 'User ID is required for tool authz',
nonRetryable: true,
})
}
// 1. Fetch User
const user = await prisma.user.findUnique({ where: { id: userId } })
if (!user) {
throw ApplicationFailure.create({
message: `User not found: ${userId}`,
nonRetryable: true,
})
}
// 2. Perform Authz and Action based on toolName
switch (toolName) {
case 'list_assets': {
const parent = args.parent
if (!parent) {
throw ApplicationFailure.create({
message: 'parent parameter is required',
nonRetryable: true,
})
}
// Authz check
await authzService.hasPermission({
user,
permission: Permission.Read,
type: ResourceType.Asset,
id: parent,
})
const page = args.page || 1
const pageSize = args.pageSize || 20
const type = args.type || 'all'
// We need to list files and folders of parent dir
const where: Prisma.AssetWhereInput = {
parentId: parent,
isDeleted: false,
}
if (type === 'file') {
where.type = { in: ['file', 'version_stack'] }
} else if (type === 'folder') {
where.type = 'folder'
} else {
where.type = { in: ['file', 'folder', 'version_stack'] }
}
const limit = pageSize
const offset = (page - 1) * limit
const after = offset > 0 ? encodeCursor(offset) : undefined
const { data: assets, pageInfo } = await paginateQuery<
Prisma.AssetGetPayload<Record<string, never>>
>(
async (skip, take) => {
return prisma.asset.findMany({
where,
orderBy: { id: 'desc' }, // sort desc per ULID default in sorting guidelines!
skip,
take,
})
},
async () => prisma.asset.count({ where }),
{ first: limit, after },
)
const stackIds = assets.filter((a) => a.type === AssetType.version_stack).map((a) => a.id)
const latestVersionsMap = new Map<string, Prisma.AssetGetPayload<Record<string, never>>>()
if (stackIds.length > 0) {
const versions = await prisma.asset.findMany({
where: { parentId: { in: stackIds }, isDeleted: false },
orderBy: { sortIndex: 'asc' },
})
for (const v of versions) {
if (!latestVersionsMap.has(v.parentId!)) {
latestVersionsMap.set(v.parentId!, v)
}
}
}
// return asset id, asset name, asset type, asset size (sizeByte or size)
const results = assets.map((a) => {
const latestVersion = latestVersionsMap.get(a.id)
return {
id: a.id,
name: a.type === AssetType.version_stack ? (latestVersion?.name ?? a.name) : a.name,
type: a.type,
size:
a.type === AssetType.version_stack && latestVersion
? Number(latestVersion.sizeByte)
: Number(a.sizeByte),
}
})
return {
assets: results,
pageInfo,
}
}
case 'create_folder': {
const parent = args.parent
const name = args.name
if (!parent || !name) {
throw ApplicationFailure.create({
message: 'parent and name parameters are required',
nonRetryable: true,
})
}
// Authz check
await authzService.hasPermission({
user,
permission: Permission.Edit,
type: ResourceType.Asset,
id: parent,
})
const newFolder = await assetService.createAsset({
name,
parentId: parent,
type: 'folder',
creatorId: userId,
})
return {
id: newFolder.id,
name: newFolder.name,
type: newFolder.type,
size: Number(newFolder.sizeByte),
}
}
case 'create_file': {
const parent = args.parent
const s3Key = args.s3Key as string
const name = args.name as string
const fileSize = args.size as number
const mimeType = args.contentType as string
const metadata =
typeof args.metadata === 'object' && args.metadata !== null
? (args.metadata as Record<string, unknown>)
: undefined
if (!parent || !s3Key || !name || fileSize === undefined || !mimeType) {
throw ApplicationFailure.create({
message: 'parent, s3Key, name, size, and contentType parameters are required',
nonRetryable: true,
})
}
// Authz check
await authzService.hasPermission({
user,
permission: Permission.Edit,
type: ResourceType.Asset,
id: parent,
})
// Fetch parent folder to resolve projectId and teamId
const parentAsset = await prisma.asset.findUnique({
where: { id: parent },
include: { project: true },
})
if (!parentAsset) {
throw ApplicationFailure.create({
message: `Parent folder not found with ID: ${parent}`,
nonRetryable: true,
})
}
if (!parentAsset.projectId || !parentAsset.project?.teamId) {
throw ApplicationFailure.create({
message: `Parent folder ${parent} has no project or team associated`,
nonRetryable: true,
})
}
// Validate that any provided metadata keys are defined CREATION_CONTEXT fields
await validateCreationContextMetadata(userId, parentAsset.projectId, metadata)
// Create asset via assetService
const newFile = await assetService.createAsset({
name,
type: 'file',
parentId: parent,
key: s3Key,
sizeByte: fileSize,
contentType: mimeType,
creatorId: userId,
})
// Increment update ancestor size
await prisma.$transaction(async (tx) => {
// eslint-disable-next-line @typescript-eslint/no-explicit-any
await assetService.updateAncestorsSize(tx as any, parent, fileSize)
// Persist creation context metadata provided by the agent
if (metadata) {
const metadataUpdates = Object.entries(metadata)
.filter(([, value]) => value !== null)
.map(([key, value]) => ({ key, value }))
if (metadataUpdates.length > 0) {
await metadataService.updateAssetMetadataInTx(tx, newFile.id, metadataUpdates)
}
}
// Trigger post-upload transcode and AI workflows
await uploadService.triggerPostUploadWorkflows(
tx,
newFile.id,
parentAsset.project!.teamId,
parentAsset.projectId!,
)
})
return {
id: newFile.id,
name: newFile.name,
type: newFile.type,
size: Number(newFile.sizeByte),
}
}
case 'create_version': {
const parent = args.parent // parent file id
const s3Key = args.s3Key as string
const name = args.name as string
const fileSize = args.size as number
const mimeType = args.contentType as string
const metadata =
typeof args.metadata === 'object' && args.metadata !== null
? (args.metadata as Record<string, unknown>)
: undefined
if (!parent || !s3Key || !name || fileSize === undefined || !mimeType) {
throw ApplicationFailure.create({
message: 'parent, s3Key, name, size, and contentType parameters are required',
nonRetryable: true,
})
}
// Fetch parent file and cast to any due to Prisma type resolution limits
/* prettier-ignore */
// eslint-disable-next-line @typescript-eslint/no-explicit-any
const parentFile = (await prisma.asset.findUnique({ where: { id: parent }, include: { parent: true, project: true } })) as any
if (!parentFile) {
throw ApplicationFailure.create({
message: `Parent file not found with ID: ${parent}`,
nonRetryable: true,
})
}
if (!parentFile.projectId || !parentFile.project?.teamId) {
throw ApplicationFailure.create({
message: `Parent file ${parent} has no project or team associated`,
nonRetryable: true,
})
}
// Validate that any provided metadata keys are defined CREATION_CONTEXT fields
await validateCreationContextMetadata(userId, parentFile.projectId, metadata)
// Authz check: verify Edit permission on the parent file (resource ID is parent file id)
await authzService.hasPermission({
user,
permission: Permission.Edit,
type: ResourceType.Asset,
id: parent,
})
// If already in a version stack
if (parentFile.parentId && parentFile.parent?.type === AssetType.version_stack) {
const stackId = parentFile.parentId
// Create the new file asset
const newFile = await assetService.createAsset({
name,
type: 'file',
parentId: stackId,
key: s3Key,
sizeByte: fileSize,
contentType: mimeType,
creatorId: userId,
})
// Generate sort index for new version inside the stack (newest gets the lowest sortIndex)
const firstChild = await prisma.asset.findFirst({
where: {
parentId: stackId,
NOT: { id: newFile.id },
},
orderBy: { sortIndex: 'asc' },
})
const newSortIndex = generateKeyBetween(null, firstChild?.sortIndex || null)
await prisma.$transaction(async (tx) => {
// Assign sort index
await tx.asset.update({
where: { id: newFile.id },
data: { sortIndex: newSortIndex },
})
// Persist creation context metadata provided by the agent
if (metadata) {
const metadataUpdates = Object.entries(metadata)
.filter(([, value]) => value !== null)
.map(([key, value]) => ({ key, value }))
if (metadataUpdates.length > 0) {
await metadataService.updateAssetMetadataInTx(tx, newFile.id, metadataUpdates)
}
}
// Increment stack's size (fileCount is incremented by createAsset already)
const updatedStack = await tx.asset.update({
where: { id: stackId },
data: {
sizeByte: { increment: fileSize },
},
})
// Update ancestors' size of stack's parent
if (updatedStack.parentId) {
// eslint-disable-next-line @typescript-eslint/no-explicit-any
await assetService.updateAncestorsSize(tx as any, updatedStack.parentId, fileSize)
}
// Trigger post-upload transcode and AI workflows
await uploadService.triggerPostUploadWorkflows(
tx,
newFile.id,
parentFile.project.teamId,
parentFile.projectId,
)
})
return {
id: newFile.id,
name: newFile.name,
type: newFile.type,
size: Number(newFile.sizeByte),
}
} else {
// Parent is a regular file. We must create a new version stack.
const folderParentId = parentFile.parentId
if (!folderParentId) {
throw ApplicationFailure.create({
message: `Parent file ${parent} has no parent folder`,
nonRetryable: true,
})
}
// Create the new file asset under parent folder first (so that createVersionStack can run on them,
// which enforces both files must have same parent initially)
const newFile = await assetService.createAsset({
name,
type: 'file',
parentId: folderParentId,
key: s3Key,
sizeByte: fileSize,
contentType: mimeType,
creatorId: userId,
})
await prisma.$transaction(async (tx) => {
// eslint-disable-next-line @typescript-eslint/no-explicit-any
const txVersionStackService = new VersionStackService(tx as any)
await txVersionStackService.createVersionStack({
fileIds: [newFile.id, parentFile.id],
projectId: parentFile.projectId!,
creatorId: userId,
})
// Persist creation context metadata provided by the agent
if (metadata) {
const metadataUpdates = Object.entries(metadata)
.filter(([, value]) => value !== null)
.map(([key, value]) => ({ key, value }))
if (metadataUpdates.length > 0) {
await metadataService.updateAssetMetadataInTx(tx, newFile.id, metadataUpdates)
}
}
// Update ancestors' size (add size of the new file version)
// eslint-disable-next-line @typescript-eslint/no-explicit-any
await assetService.updateAncestorsSize(tx as any, folderParentId!, fileSize)
// Trigger post-upload transcode and AI workflows
await uploadService.triggerPostUploadWorkflows(
tx,
newFile.id,
parentFile.project.teamId,
parentFile.projectId!,
)
})
return {
id: newFile.id,
name: newFile.name,
type: newFile.type,
size: Number(newFile.sizeByte),
}
}
}
default:
throw ApplicationFailure.create({
message: `Unsupported tool name: ${toolName}`,
nonRetryable: true,
})
}
export async function getAssetPathContextActivity(assetId: string): Promise<string> {
const { path } = await getAssetPathHierarchyActivity(assetId)
return path
}
export interface GenerateSessionNameParams {
@@ -0,0 +1,315 @@
import { describe, it, expect } from 'vitest'
import { escapeXmlAttr, serializeContextToXml } from './serialize-context'
import type { ShumaiMessageContext } from '@shumai/dtos'
describe('serializeContextToXml', () => {
describe('escapeXmlAttr', () => {
it('escapes &, <, >, ", and \' characters correctly', () => {
expect(escapeXmlAttr('Alice & Bob <Admin> "v1" \'test\'')).toBe(
'Alice &amp; Bob &lt;Admin&gt; &quot;v1&quot; &apos;test&apos;',
)
})
it('handles clean strings without modification', () => {
expect(escapeXmlAttr('normal-string_123.mp4')).toBe('normal-string_123.mp4')
})
})
describe('Tag Serialization', () => {
it('returns empty string for null, undefined, or empty context', () => {
expect(serializeContextToXml(null)).toBe('')
expect(serializeContextToXml(undefined)).toBe('')
expect(serializeContextToXml({})).toBe('')
})
it('serializes minimal context with only user', () => {
const context: ShumaiMessageContext = {
user: { id: 'usr_1', name: 'Alice', role: 'editor' },
}
expect(serializeContextToXml(context)).toBe(
'<context>\n <user id="usr_1" name="Alice" role="editor" />\n</context>',
)
})
it('serializes minimal context with only currentAsset (without ancestors)', () => {
const context: ShumaiMessageContext = {
currentAsset: {
id: 'ast_1',
name: 'clip.mp4',
type: 'file',
mediaType: 'video',
path: 'clip.mp4',
},
}
expect(serializeContextToXml(context)).toBe(
'<context>\n <current_asset id="ast_1" name="clip.mp4" type="file" media_type="video" path="clip.mp4" />\n</context>',
)
})
it('serializes full video context with duration, timestamp, annotation, attached files, and referenced assets', () => {
const context: ShumaiMessageContext = {
user: { id: 'usr_01', name: 'Alice Chen', role: 'editor' },
currentAsset: {
id: 'ast_01JC04_CURRENT',
name: 'product_launch_v2.mp4',
type: 'file',
mediaType: 'video',
parentId: 'ast_01JC03_PARENT',
path: 'Marketing/2026_Launch/Footage/product_launch_v2.mp4',
durationSeconds: 85.4,
ancestors: [
{ id: 'ast_01JC01_ROOT', name: 'Marketing' },
{ id: 'ast_01JC02_SUB', name: '2026_Launch' },
{ id: 'ast_01JC03_PARENT', name: 'Footage' },
],
},
position: { type: 'time', seconds: 14.25 },
annotation: true,
attachedFiles: [
{
id: 'ast_01JC05_ATT1',
name: 'brand_guidelines_2026.pdf',
type: 'file',
mediaType: 'pdf',
path: 'Brand/brand_guidelines_2026.pdf',
},
],
referencedAssets: [
{
id: 'ast_01JC07_REF2',
name: 'Color_LUTs',
type: 'folder',
path: 'Assets/Color_LUTs',
},
{
id: 'ast_01JC06_REF1',
name: 'logo_white.png',
type: 'file',
mediaType: 'image',
path: 'Brand/Logos/logo_white.png',
},
],
}
const expected = `<context>
<user id="usr_01" name="Alice Chen" role="editor" />
<current_asset id="ast_01JC04_CURRENT" name="product_launch_v2.mp4" type="file" media_type="video" parent_id="ast_01JC03_PARENT" path="Marketing/2026_Launch/Footage/product_launch_v2.mp4" duration_seconds="85.40">
<ancestors>
<folder id="ast_01JC01_ROOT" name="Marketing" />
<folder id="ast_01JC02_SUB" name="2026_Launch" />
<folder id="ast_01JC03_PARENT" name="Footage" />
</ancestors>
</current_asset>
<position type="time" seconds="14.25" />
<annotation />
<attached_files>
<file id="ast_01JC05_ATT1" name="brand_guidelines_2026.pdf" type="file" media_type="pdf" path="Brand/brand_guidelines_2026.pdf" />
</attached_files>
<referenced_assets>
<asset id="ast_01JC06_REF1" name="logo_white.png" type="file" media_type="image" path="Brand/Logos/logo_white.png" />
<folder id="ast_01JC07_REF2" name="Color_LUTs" path="Assets/Color_LUTs" />
</referenced_assets>
</context>`
expect(serializeContextToXml(context)).toBe(expected)
})
it('serializes PDF document context with total_pages and position.type === "page"', () => {
const context: ShumaiMessageContext = {
currentAsset: {
id: 'pdf_1',
name: 'report.pdf',
type: 'file',
mediaType: 'pdf',
totalPages: 12,
},
position: { type: 'page', page: 3 },
}
const expected = `<context>
<current_asset id="pdf_1" name="report.pdf" type="file" media_type="pdf" total_pages="12" />
<position type="page" page="3" />
</context>`
expect(serializeContextToXml(context)).toBe(expected)
})
it('serializes Video context with total_frames and duration_seconds', () => {
const context: ShumaiMessageContext = {
currentAsset: {
id: 'vid_1',
name: 'clip.mp4',
type: 'file',
mediaType: 'video',
mimeType: 'video/mp4',
durationSeconds: 9,
totalFrames: 268,
},
}
const expected = `<context>
<current_asset id="vid_1" name="clip.mp4" type="file" media_type="video" mime_type="video/mp4" duration_seconds="9.00" total_frames="268" />
</context>`
expect(serializeContextToXml(context)).toBe(expected)
})
it('serializes navigation context with navigated="true" and ancestors hierarchy', () => {
const context: ShumaiMessageContext = {
currentAsset: {
id: 'f_sub',
name: 'Subfolder',
type: 'folder',
navigated: true,
ancestors: [{ id: 'f_root', name: 'Root' }],
},
}
const expected = `<context>
<current_asset id="f_sub" name="Subfolder" type="folder" navigated="true">
<ancestors>
<folder id="f_root" name="Root" />
</ancestors>
</current_asset>
</context>`
expect(serializeContextToXml(context)).toBe(expected)
})
it('serializes mime_type alongside media_type for current asset and attached files', () => {
const context: ShumaiMessageContext = {
currentAsset: {
id: 'img_1',
name: 'photo.png',
type: 'file',
mediaType: 'image',
mimeType: 'image/png',
},
attachedFiles: [
{
id: 'doc_1',
name: 'spec.pdf',
type: 'file',
mediaType: 'pdf',
mimeType: 'application/pdf',
},
],
}
const expected = `<context>
<current_asset id="img_1" name="photo.png" type="file" media_type="image" mime_type="image/png" />
<attached_files>
<file id="doc_1" name="spec.pdf" type="file" media_type="pdf" mime_type="application/pdf" />
</attached_files>
</context>`
expect(serializeContextToXml(context)).toBe(expected)
})
})
describe('XML Escaping & Security', () => {
it('escapes user names, asset names, and paths with special characters', () => {
const context: ShumaiMessageContext = {
user: {
id: 'u_1',
name: 'Alice & Bob <Admin>',
role: 'reviewer "lead"',
},
currentAsset: {
id: 'ast_1',
name: 'Final <Cut> "v2" & Test.mp4',
type: 'file',
path: 'Folder A > Folder B & C/clip.mp4',
ancestors: [{ id: 'anc_1', name: 'Folder B & C' }],
},
attachedFiles: [
{
id: 'att_1',
name: "Don't <Touch> & Go.pdf",
type: 'file',
path: "Path 'A' & 'B'/doc.pdf",
},
],
}
const xml = serializeContextToXml(context)
expect(xml).toContain('name="Alice &amp; Bob &lt;Admin&gt;"')
expect(xml).toContain('role="reviewer &quot;lead&quot;"')
expect(xml).toContain('name="Final &lt;Cut&gt; &quot;v2&quot; &amp; Test.mp4"')
expect(xml).toContain('path="Folder A &gt; Folder B &amp; C/clip.mp4"')
expect(xml).toContain('name="Folder B &amp; C"')
expect(xml).toContain('name="Don&apos;t &lt;Touch&gt; &amp; Go.pdf"')
expect(xml).toContain('path="Path &apos;A&apos; &amp; &apos;B&apos;/doc.pdf"')
// Verify no unescaped dangerous characters exist inside attribute quotes
const attrMatch = xml.match(/\w+="([^"]*)"/g)
expect(attrMatch).not.toBeNull()
})
})
describe('Order Stability & Prompt Caching Invariants', () => {
it('produces identical XML regardless of object key order', () => {
const contextA: ShumaiMessageContext = {
user: { role: 'editor', name: 'Alice', id: 'u_1' },
currentAsset: {
name: 'video.mp4',
type: 'file',
id: 'ast_1',
mediaType: 'video',
},
position: { seconds: 12.345, type: 'time' },
}
const contextB: ShumaiMessageContext = {
position: { type: 'time', seconds: 12.345 },
currentAsset: {
id: 'ast_1',
mediaType: 'video',
type: 'file',
name: 'video.mp4',
},
user: { id: 'u_1', name: 'Alice', role: 'editor' },
}
expect(serializeContextToXml(contextA)).toBe(serializeContextToXml(contextB))
})
it('sorts attachedFiles and referencedAssets by id ascending', () => {
const context: ShumaiMessageContext = {
attachedFiles: [
{ id: 'z_file', name: 'Z', type: 'file' },
{ id: 'a_file', name: 'A', type: 'file' },
{ id: 'm_file', name: 'M', type: 'file' },
],
referencedAssets: [
{ id: 'z_asset', name: 'Z', type: 'file' },
{ id: 'a_asset', name: 'A', type: 'folder' },
{ id: 'm_asset', name: 'M', type: 'file' },
],
}
const xml = serializeContextToXml(context)
const fileOrder = [...xml.matchAll(/<file id="([^"]+)"/g)].map((m) => m[1])
const refOrder = [...xml.matchAll(/<(?:asset|folder) id="([^"]+)"/g)].map((m) => m[1])
expect(fileOrder).toEqual(['a_file', 'm_file', 'z_file'])
expect(refOrder).toEqual(['a_asset', 'm_asset', 'z_asset'])
})
it('normalizes float formatting with fixed .toFixed(2)', () => {
const context1: ShumaiMessageContext = {
currentAsset: { id: '1', name: 'a', type: 'file', durationSeconds: 14 },
position: { type: 'time', seconds: 5.5 },
}
const context2: ShumaiMessageContext = {
currentAsset: { id: '1', name: 'a', type: 'file', durationSeconds: 14.0001 },
position: { type: 'time', seconds: 5.50002 },
}
expect(serializeContextToXml(context1)).toContain('duration_seconds="14.00"')
expect(serializeContextToXml(context1)).toContain('seconds="5.50"')
expect(serializeContextToXml(context2)).toContain('duration_seconds="14.00"')
expect(serializeContextToXml(context2)).toContain('seconds="5.50"')
})
})
})
@@ -0,0 +1 @@
export { escapeXmlAttr, serializeContextToXml } from '@shumai/dtos'
@@ -662,5 +662,85 @@ describe('DatabaseSessionStorage', () => {
expect(stats.totalTokens).toBe(170)
expect(stats.costTotal).toBeCloseTo(0.032)
})
it('should save user message turn as custom_message (shumai_message) in DB when currentMessageContext is set', async () => {
const { agent, user } = await setupTestData()
const storage = await DatabaseSessionStorage.create({ agentId: agent.id, userId: user.id })
storage.currentMessageContext = {
user: { id: user.id, name: user.name, role: 'owner' },
currentAsset: { id: 'asset-123', name: 'video.mp4', type: 'file' },
}
const userEntry: SessionTreeEntry = {
type: 'message',
id: 'msg-user-1',
parentId: null,
timestamp: new Date().toISOString(),
message: {
role: 'user',
content: 'Hello, help me analyze this video',
timestamp: Date.now(),
},
}
await storage.appendEntry(userEntry)
// 1. Verify DB record type is 'custom_message', not 'message'
const record = await prisma.agentSessionEntry.findUnique({
where: { id: 'msg-user-1' },
})
expect(record).toBeDefined()
expect(record?.type).toBe('custom_message')
// eslint-disable-next-line @typescript-eslint/no-explicit-any
const data = record?.data as any
expect(data.customType).toBe('shumai_message')
expect(data.content).toBe('Hello, help me analyze this video')
expect(data.details?.user?.id).toBe(user.id)
expect(data.details?.currentAsset?.id).toBe('asset-123')
// 2. Verify getEntries() and getPathToRoot() do not throw and return proper custom_message
const entries = await storage.getEntries()
expect(entries).toHaveLength(1)
expect(entries[0].type).toBe('custom_message')
const pathEntries = await storage.getPathToRoot('msg-user-1')
expect(pathEntries).toHaveLength(1)
expect(pathEntries[0].type).toBe('custom_message')
const stats = await storage.getSessionStats()
expect(stats.messageCount).toBe(1)
})
it('should safely handle legacy records where type was message but data was shumai_message', async () => {
const { agent } = await setupTestData()
const storage = await DatabaseSessionStorage.create({ agentId: agent.id })
await prisma.agentSessionEntry.create({
data: {
id: 'legacy-corrupted-entry',
sessionId: storage.sessionId,
type: 'message',
data: {
customType: 'shumai_message',
content: 'Legacy prompt',
display: true,
details: { user: { id: 'u1', name: 'User 1' } },
},
},
})
// Must not throw in getEntries(), getPathToRoot(), or getSessionStats()
const entries = await storage.getEntries()
expect(entries).toHaveLength(1)
expect(entries[0].type).toBe('custom_message')
const path = await storage.getPathToRoot('legacy-corrupted-entry')
expect(path).toHaveLength(1)
expect(path[0].type).toBe('custom_message')
const stats = await storage.getSessionStats()
expect(stats.messageCount).toBe(1)
})
})
})
+75 -22
View File
@@ -72,6 +72,7 @@ export class DatabaseSessionStorage implements SessionStorage<DatabaseSessionMet
}
nextEntryId?: string | null
currentMessageContext?: PrismaJson.ShumaiMessageContext
async createEntryId(): Promise<string> {
if (this.nextEntryId) {
@@ -90,9 +91,13 @@ export class DatabaseSessionStorage implements SessionStorage<DatabaseSessionMet
data: unknown
}): SessionTreeEntry {
const payload = (record.data as Record<string, unknown>) || {}
let type = (record.type || 'message') as SessionTreeEntry['type']
if (type === 'message' && payload.customType === 'shumai_message') {
type = 'custom_message'
}
return {
id: record.id,
type: (record.type || 'message') as SessionTreeEntry['type'],
type,
parentId: record.parentId,
timestamp: record.createdAt.toISOString(),
...payload,
@@ -100,10 +105,41 @@ export class DatabaseSessionStorage implements SessionStorage<DatabaseSessionMet
}
async appendEntry(entry: SessionTreeEntry): Promise<void> {
const strippedEntry = structuredClone(entry)
let entryToProcess = entry
if (
entryToProcess.type === 'message' &&
entryToProcess.message &&
entryToProcess.message.role === 'user' &&
this.currentMessageContext
) {
let contentText = ''
if (typeof entryToProcess.message.content === 'string') {
contentText = entryToProcess.message.content
} else if (Array.isArray(entryToProcess.message.content)) {
contentText = entryToProcess.message.content
.map((c) =>
typeof c === 'object' && c && 'text' in c && typeof c.text === 'string' ? c.text : '',
)
.join('')
}
entryToProcess = {
type: 'custom_message',
id: entryToProcess.id,
parentId: entryToProcess.parentId,
timestamp: entryToProcess.timestamp,
customType: 'shumai_message',
content: contentText,
display: true,
details: this.currentMessageContext,
} as unknown as SessionTreeEntry
this.currentMessageContext = undefined
}
const strippedEntry = structuredClone(entryToProcess)
// Strip image data and skill content before saving to DB
if (strippedEntry.type === 'message') {
if (strippedEntry.type === 'message' && strippedEntry.message) {
const msg = strippedEntry.message
if (msg.role === 'toolResult') {
const details = msg.details as { sourceKeys?: string[]; skillId?: string } | undefined
@@ -139,7 +175,10 @@ export class DatabaseSessionStorage implements SessionStorage<DatabaseSessionMet
}
}
const targetLeafId = entry.type === 'leaf' ? entry.targetId : entry.id
const targetLeafId =
strippedEntry.type === 'leaf'
? (strippedEntry as unknown as { targetId?: string }).targetId || strippedEntry.id
: strippedEntry.id
// Extract base fields and store type-specific properties in data payload
const payload = { ...strippedEntry } as Record<string, unknown>
@@ -155,17 +194,18 @@ export class DatabaseSessionStorage implements SessionStorage<DatabaseSessionMet
await prisma.$transaction([
prisma.agentSessionEntry.upsert({
where: { id: entry.id },
where: { id: strippedEntry.id },
create: {
id: entry.id,
id: strippedEntry.id,
sessionId: this.sessionId,
assetId: session?.assetId || null,
type: entry.type,
parentId: entry.parentId || null,
createdAt: entry.timestamp ? new Date(entry.timestamp) : new Date(),
type: strippedEntry.type,
parentId: strippedEntry.parentId || null,
createdAt: strippedEntry.timestamp ? new Date(strippedEntry.timestamp) : new Date(),
data: payload as PrismaJson.PiSessionEntryData,
},
update: {
type: strippedEntry.type,
data: payload as PrismaJson.PiSessionEntryData,
},
}),
@@ -236,7 +276,9 @@ export class DatabaseSessionStorage implements SessionStorage<DatabaseSessionMet
let costTotal = 0
for (const entry of entries) {
if (entry.type === 'message') {
if (entry.type === 'custom_message' && entry.customType === 'shumai_message') {
messageCount++
} else if (entry.type === 'message' && entry.message) {
const msg = entry.message
if (msg.role === 'user' || msg.role === 'assistant') {
messageCount++
@@ -348,18 +390,29 @@ export class DatabaseSessionStorage implements SessionStorage<DatabaseSessionMet
for (let i = 0; i < pathEntries.length; i++) {
const entry = pathEntries[i]
const count = threadReplyCountMap.get(entry.id)
if (count !== undefined && count > 0 && entry.type === 'message') {
const cloned = structuredClone(entry)
const msg = cloned.message as unknown as {
content?: Array<{ type: string; text: string }>
}
if (Array.isArray(msg.content) && msg.content[0] && msg.content[0].type === 'text') {
const threadTag = `[Thread ID: ${entry.id}] [Replies: ${count}]`
if (!msg.content[0].text.includes(`[Thread ID: ${entry.id}]`)) {
msg.content[0].text = `${threadTag} ${msg.content[0].text}`
if (count !== undefined && count > 0) {
if (entry.type === 'message' && entry.message) {
const cloned = structuredClone(entry)
const msg = cloned.message as unknown as {
content?: Array<{ type: string; text: string }>
}
if (Array.isArray(msg.content) && msg.content[0] && msg.content[0].type === 'text') {
const threadTag = `[Thread ID: ${entry.id}] [Replies: ${count}]`
if (!msg.content[0].text.includes(`[Thread ID: ${entry.id}]`)) {
msg.content[0].text = `${threadTag} ${msg.content[0].text}`
}
}
pathEntries[i] = cloned
} else if (entry.type === 'custom_message') {
const cloned = structuredClone(entry)
const threadTag = `[Thread ID: ${entry.id}] [Replies: ${count}]`
if (typeof cloned.content === 'string') {
if (!cloned.content.includes(`[Thread ID: ${entry.id}]`)) {
cloned.content = `${threadTag} ${cloned.content}`
}
}
pathEntries[i] = cloned
}
pathEntries[i] = cloned
}
}
}
@@ -382,7 +435,7 @@ export class DatabaseSessionStorage implements SessionStorage<DatabaseSessionMet
}
private async reinjectImageDataAsync(entry: SessionTreeEntry) {
if (entry.type === 'message') {
if (entry.type === 'message' && entry.message) {
const msg = entry.message as AgentMessage
if (msg.role === 'toolResult') {
const details = msg.details as { sourceKeys?: string[] } | undefined
@@ -407,7 +460,7 @@ export class DatabaseSessionStorage implements SessionStorage<DatabaseSessionMet
}
private async reinjectSkillContentAsync(entry: SessionTreeEntry) {
if (entry.type === 'message') {
if (entry.type === 'message' && entry.message) {
const msg = entry.message as AgentMessage
if (msg.role === 'toolResult' && msg.toolName === 'read_skill') {
const details = msg.details as { skillId?: string } | undefined
+27 -3
View File
@@ -30,6 +30,8 @@ import { createReadSkillTool } from './tools/read-skill'
import { createReadThreadTool } from './tools/read-thread'
import { createSandboxedBashTool } from './tools/sandboxed-bash'
import { createScreenshotTool } from './tools/screenshot'
import { serializeContextToXml } from './context/serialize-context'
import type { ShumaiMessageContext } from '@shumai/dtos'
export interface DbModelInfo {
modelId: string
@@ -292,6 +294,7 @@ export async function createAgentSession(params: CreateAgentSessionParams) {
for (const entry of entries) {
if (
entry.type === 'message' &&
entry.message &&
entry.message.role === 'toolResult' &&
entry.message.toolName === 'read_skill' &&
!entry.message.isError
@@ -445,6 +448,29 @@ export async function createAgentSession(params: CreateAgentSessionParams) {
tools: enabledTools,
})
harness.on('context', async ({ messages }) => {
return {
messages: messages.map((msg) => {
if (
msg.role === 'custom' &&
msg.customType === 'shumai_message' &&
msg.details &&
typeof msg.details === 'object'
) {
const context = msg.details as ShumaiMessageContext
const xml = serializeContextToXml(context)
const text = typeof msg.content === 'string' ? msg.content : ''
const fullContent = xml ? `${text}\n\n${xml}`.trim() : text
return {
...msg,
content: fullContent,
}
}
return msg
}),
}
})
return { session, harness }
}
@@ -613,7 +639,6 @@ import * as aiActivities from './activities/ai'
import { agentAutofillMedia } from './workflows/agent-autofill'
import { agentChat } from './workflows/agent-chat'
import { agentEmbeddingMedia } from './workflows/agent-embedding'
import { agentToolCall } from './workflows/agent-tool-call'
import { queryEmbeddingForSearch } from './workflows/query-embedding-for-search'
export function initAgentWorkflows() {
@@ -621,7 +646,6 @@ export function initAgentWorkflows() {
registerWorkflow(WorkflowTaskType.query_embedding_for_search, queryEmbeddingForSearch)
registerWorkflow(WorkflowTaskType.ai_metadata_autofill, agentAutofillMedia)
registerWorkflow(WorkflowTaskType.chat, agentChat)
registerWorkflow(WorkflowTaskType.agent_tool_call, agentToolCall)
registerActivities(agentActivities)
registerActivities(aiActivities)
@@ -640,8 +664,8 @@ export {
type GenerateTextEmbeddingParams,
} from './activities/ai'
export * from './database-session-storage'
export * from './context/serialize-context'
export * from './workflows/agent-autofill'
export * from './workflows/agent-chat'
export * from './workflows/agent-embedding'
export * from './workflows/agent-tool-call'
export * from './workflows/query-embedding-for-search'
@@ -3,7 +3,8 @@ import { validateToolArguments } from '@earendil-works/pi-ai'
import { createCreateFileTool } from './tools/create-file'
import { fieldsToTypeBoxSchema } from './index'
import { s3Service } from '@shumai/core/src/s3/s3'
import { executeAgentToolWorkflow } from './tools/utils'
import { assetService } from '@shumai/core/src/asset/asset'
import { authzService } from '@shumai/core/src/authz/authz'
vi.mock('@shumai/core/src/s3/s3', () => ({
s3Service: {
@@ -12,8 +13,20 @@ vi.mock('@shumai/core/src/s3/s3', () => ({
},
}))
vi.mock('./tools/utils', () => ({
executeAgentToolWorkflow: vi.fn().mockResolvedValue({ id: 'file-1', name: 'test', type: 'file' }),
vi.mock('@shumai/core/src/authz/authz', () => ({
authzService: {
hasPermission: vi.fn().mockResolvedValue(undefined),
},
Permission: { Edit: 'edit', Read: 'read' },
ResourceType: { Asset: 'asset' },
}))
vi.mock('@shumai/core/src/asset/asset', () => ({
assetService: {
createFile: vi
.fn()
.mockResolvedValue({ id: 'file-1', name: 'test', type: 'file', sizeByte: 100 }),
},
}))
/**
@@ -63,9 +76,10 @@ describe('reproduce null coercion in harness tool validation', () => {
// execute must accept the valid call (data-only) without throwing
const result = await tool.execute('call-1', validated as never)
expect(result.details).toEqual({ id: 'file-1', name: 'test', type: 'file' })
expect(result.details).toEqual({ id: 'file-1', name: 'test', type: 'file', size: 100 })
expect(s3Service.putObject).toHaveBeenCalledTimes(1)
expect(executeAgentToolWorkflow).toHaveBeenCalledTimes(1)
expect(authzService.hasPermission).toHaveBeenCalledTimes(1)
expect(assetService.createFile).toHaveBeenCalledTimes(1)
})
it('keeps null metadata values (the "unknown" sentinel) through validation', () => {
+56 -46
View File
@@ -2,7 +2,8 @@ import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
import { createCreateFileTool } from './create-file'
import { fieldsToTypeBoxSchema } from '../index'
import { s3Service } from '@shumai/core/src/s3/s3'
import { executeAgentToolWorkflow } from './utils'
import { assetService } from '@shumai/core/src/asset/asset'
import { authzService } from '@shumai/core/src/authz/authz'
import { Value } from 'typebox/value'
import * as fs from 'fs'
import * as os from 'os'
@@ -15,8 +16,20 @@ vi.mock('@shumai/core/src/s3/s3', () => ({
},
}))
vi.mock('./utils', () => ({
executeAgentToolWorkflow: vi.fn().mockResolvedValue({ id: 'file-1', name: 'test', type: 'file' }),
vi.mock('@shumai/core/src/authz/authz', () => ({
authzService: {
hasPermission: vi.fn().mockResolvedValue(undefined),
},
Permission: { Edit: 'edit', Read: 'read' },
ResourceType: { Asset: 'asset' },
}))
vi.mock('@shumai/core/src/asset/asset', () => ({
assetService: {
createFile: vi
.fn()
.mockResolvedValue({ id: 'file-1', name: 'test', type: 'file', sizeByte: 100 }),
},
}))
describe('createCreateFileTool', () => {
@@ -56,23 +69,27 @@ describe('createCreateFileTool', () => {
expect(s3Key).toMatch(/^files\/.+\.md$/)
expect(uploadArgs[2]).toBe('text/markdown')
expect(executeAgentToolWorkflow).toHaveBeenCalledWith({
toolName: 'create_file',
args: {
parent: 'folder-1',
s3Key,
name: 'create-file-test.md',
size: Buffer.byteLength('# Hello from disk', 'utf-8'),
contentType: 'text/markdown',
},
userId: 'user-1',
assetId: 'folder-1',
expect(authzService.hasPermission).toHaveBeenCalledWith({
user: { id: 'user-1' },
permission: 'edit',
type: 'asset',
id: 'folder-1',
})
expect(result.details).toEqual({ id: 'file-1', name: 'test', type: 'file' })
expect(assetService.createFile).toHaveBeenCalledWith({
parentId: 'folder-1',
name: 'create-file-test.md',
key: s3Key,
sizeByte: Buffer.byteLength('# Hello from disk', 'utf-8'),
contentType: 'text/markdown',
creatorId: 'user-1',
metadata: undefined,
})
expect(result.details).toEqual({ id: 'file-1', name: 'test', type: 'file', size: 100 })
})
it('should forward the metadata to the agent tool workflow when provided', async () => {
it('should forward the metadata to assetService.createFile when provided', async () => {
const filePath = createTempFile('# Hello from disk', 'create-file-metadata.md')
const metadataSchema = fieldsToTypeBoxSchema([
{ id: 'prompt', config: { name: 'Prompt', type: 'text' } },
@@ -86,9 +103,9 @@ describe('createCreateFileTool', () => {
metadata: { prompt: 'Generated using gemini' },
})
expect(executeAgentToolWorkflow).toHaveBeenCalledWith(
expect(assetService.createFile).toHaveBeenCalledWith(
expect.objectContaining({
args: expect.objectContaining({ metadata: { prompt: 'Generated using gemini' } }),
metadata: { prompt: 'Generated using gemini' },
}),
)
})
@@ -125,19 +142,17 @@ describe('createCreateFileTool', () => {
},
})
expect(executeAgentToolWorkflow).toHaveBeenCalledWith(
expect(assetService.createFile).toHaveBeenCalledWith(
expect.objectContaining({
args: expect.objectContaining({
metadata: {
provider: { newOption: { value: 'Kling' } },
tags: ['tag1', { newOption: { value: 'Tag 2' } }],
},
}),
metadata: {
provider: { newOption: { value: 'Kling' } },
tags: ['tag1', { newOption: { value: 'Tag 2' } }],
},
}),
)
})
it('should not include metadata in args when metadata is null', async () => {
it('should not include metadata when metadata is null', async () => {
const filePath = createTempFile('# Hello from disk', 'create-file-no-metadata.md')
const metadataSchema = fieldsToTypeBoxSchema([
{ id: 'prompt', config: { name: 'Prompt', type: 'text' } },
@@ -151,8 +166,8 @@ describe('createCreateFileTool', () => {
metadata: null,
})
const callArgs = vi.mocked(executeAgentToolWorkflow).mock.calls[0][0].args
expect(callArgs).not.toHaveProperty('metadata')
const callArgs = vi.mocked(assetService.createFile).mock.calls[0][0]
expect(callArgs.metadata).toBeUndefined()
})
it('should throw when the local file does not exist', async () => {
@@ -161,7 +176,7 @@ describe('createCreateFileTool', () => {
tool.execute('call-1', { parent: 'folder-1', path: '/nonexistent/file.md', data: null }),
).rejects.toThrow('Local file not found at path: /nonexistent/file.md')
expect(s3Service.uploadFileToKey).not.toHaveBeenCalled()
expect(executeAgentToolWorkflow).not.toHaveBeenCalled()
expect(assetService.createFile).not.toHaveBeenCalled()
})
it('should create a file directly from name and content', async () => {
@@ -184,20 +199,17 @@ describe('createCreateFileTool', () => {
expect(size).toBe(Buffer.byteLength('# Notes\n\nHello', 'utf-8'))
expect(contentType).toBe('text/markdown')
expect(executeAgentToolWorkflow).toHaveBeenCalledWith({
toolName: 'create_file',
args: {
parent: 'folder-1',
s3Key,
name: 'notes.md',
size: Buffer.byteLength('# Notes\n\nHello', 'utf-8'),
contentType: 'text/markdown',
},
userId: 'user-1',
assetId: 'folder-1',
expect(assetService.createFile).toHaveBeenCalledWith({
parentId: 'folder-1',
name: 'notes.md',
key: s3Key,
sizeByte: Buffer.byteLength('# Notes\n\nHello', 'utf-8'),
contentType: 'text/markdown',
creatorId: 'user-1',
metadata: undefined,
})
expect(result.details).toEqual({ id: 'file-1', name: 'test', type: 'file' })
expect(result.details).toEqual({ id: 'file-1', name: 'test', type: 'file', size: 100 })
})
it('should default unknown extensions to text/plain when creating from content', async () => {
@@ -235,10 +247,8 @@ describe('createCreateFileTool', () => {
]
expect(s3Key).toContain('my_notes.md')
expect(executeAgentToolWorkflow).toHaveBeenCalledWith(
expect.objectContaining({
args: expect.objectContaining({ name: 'my_notes.md' }),
}),
expect(assetService.createFile).toHaveBeenCalledWith(
expect.objectContaining({ name: 'my_notes.md' }),
)
})
@@ -260,7 +270,7 @@ describe('createCreateFileTool', () => {
).rejects.toThrow('Provide exactly one of "path" (a local file) or "data" (name and content).')
expect(s3Service.uploadFileToKey).not.toHaveBeenCalled()
expect(s3Service.putObject).not.toHaveBeenCalled()
expect(executeAgentToolWorkflow).not.toHaveBeenCalled()
expect(assetService.createFile).not.toHaveBeenCalled()
})
it('should expose a strict, all-required (nullable) metadata schema when fields are provided', () => {
+26 -13
View File
@@ -1,12 +1,14 @@
import { type AgentTool } from '@earendil-works/pi-agent-core'
import { assetService } from '@shumai/core/src/asset/asset'
import { authzService, Permission, ResourceType } from '@shumai/core/src/authz/authz'
import { s3Service } from '@shumai/core/src/s3/s3'
import { getFileMimeType, readFileMimeType } from '@shumai/core/src/utils/file-mime'
import { sanitizeFilename } from '@shumai/core/src/utils/filename'
import { type User } from '@shumai/db'
import { Type, type TSchema } from 'typebox'
import * as fs from 'fs'
import * as path from 'path'
import { ulid } from 'ulid'
import { executeAgentToolWorkflow } from './utils'
interface CreateFileToolParams {
parent: string
@@ -105,19 +107,30 @@ export function createCreateFileTool(userId: string, metadataSchema?: TSchema):
await s3Service.putObject(process.env.S3_BUCKET || 'shumai', s3Key, content, size, mimeType)
}
const result = await executeAgentToolWorkflow({
toolName: 'create_file',
args: {
parent: p.parent,
s3Key,
name,
size,
contentType: mimeType,
...(p.metadata ? { metadata: p.metadata } : {}),
},
userId,
assetId: p.parent,
await authzService.hasPermission({
user: { id: userId } as User,
permission: Permission.Edit,
type: ResourceType.Asset,
id: p.parent,
})
const asset = await assetService.createFile({
parentId: p.parent,
name,
key: s3Key,
sizeByte: size,
contentType: mimeType,
creatorId: userId,
metadata: p.metadata ?? undefined,
})
const result = {
id: asset.id,
name: asset.name,
type: asset.type,
size: Number(asset.sizeByte),
}
return {
content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
details: result,
@@ -0,0 +1,55 @@
import { describe, it, expect, vi, beforeEach } from 'vitest'
import { createCreateFolderTool } from './create-folder'
import { assetService } from '@shumai/core/src/asset/asset'
import { authzService } from '@shumai/core/src/authz/authz'
vi.mock('@shumai/core/src/authz/authz', () => ({
authzService: {
hasPermission: vi.fn().mockResolvedValue(undefined),
},
Permission: { Edit: 'edit', Read: 'read' },
ResourceType: { Asset: 'asset' },
}))
vi.mock('@shumai/core/src/asset/asset', () => ({
assetService: {
createAsset: vi.fn().mockResolvedValue({
id: 'folder-1',
name: 'New Folder',
type: 'folder',
sizeByte: 0,
}),
},
}))
describe('createCreateFolderTool', () => {
beforeEach(() => {
vi.clearAllMocks()
})
it('checks edit permission and calls assetService.createAsset with folder type', async () => {
const tool = createCreateFolderTool('user-1')
const result = await tool.execute('call-1', { parent: 'root-folder', name: 'New Folder' })
expect(authzService.hasPermission).toHaveBeenCalledWith({
user: { id: 'user-1' },
permission: 'edit',
type: 'asset',
id: 'root-folder',
})
expect(assetService.createAsset).toHaveBeenCalledWith({
name: 'New Folder',
parentId: 'root-folder',
type: 'folder',
creatorId: 'user-1',
})
expect(result.details).toEqual({
id: 'folder-1',
name: 'New Folder',
type: 'folder',
size: 0,
})
})
})
+23 -6
View File
@@ -1,6 +1,8 @@
import { Type } from 'typebox'
import { type AgentTool } from '@earendil-works/pi-agent-core'
import { executeAgentToolWorkflow } from './utils'
import { assetService } from '@shumai/core/src/asset/asset'
import { authzService, Permission, ResourceType } from '@shumai/core/src/authz/authz'
import { type User } from '@shumai/db'
const createFolderSchema = Type.Object({
parent: Type.String({
@@ -19,12 +21,27 @@ export function createCreateFolderTool(userId: string): AgentTool<typeof createF
description: 'Create a new folder in a specified parent folder.',
parameters: createFolderSchema,
execute: async (_toolCallId, params) => {
const result = await executeAgentToolWorkflow({
toolName: 'create_folder',
args: params,
userId,
assetId: params.parent,
await authzService.hasPermission({
user: { id: userId } as User,
permission: Permission.Edit,
type: ResourceType.Asset,
id: params.parent,
})
const newFolder = await assetService.createAsset({
name: params.name,
parentId: params.parent,
type: 'folder',
creatorId: userId,
})
const result = {
id: newFolder.id,
name: newFolder.name,
type: newFolder.type,
size: Number(newFolder.sizeByte),
}
return {
content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
details: result,
+45 -30
View File
@@ -2,7 +2,8 @@ import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
import { createCreateVersionTool } from './create-version'
import { fieldsToTypeBoxSchema } from '../index'
import { s3Service } from '@shumai/core/src/s3/s3'
import { executeAgentToolWorkflow } from './utils'
import { assetService } from '@shumai/core/src/asset/asset'
import { authzService } from '@shumai/core/src/authz/authz'
import { Value } from 'typebox/value'
import * as fs from 'fs'
import * as os from 'os'
@@ -14,8 +15,20 @@ vi.mock('@shumai/core/src/s3/s3', () => ({
},
}))
vi.mock('./utils', () => ({
executeAgentToolWorkflow: vi.fn().mockResolvedValue({ id: 'file-1', name: 'v2', type: 'file' }),
vi.mock('@shumai/core/src/authz/authz', () => ({
authzService: {
hasPermission: vi.fn().mockResolvedValue(undefined),
},
Permission: { Edit: 'edit', Read: 'read' },
ResourceType: { Asset: 'asset' },
}))
vi.mock('@shumai/core/src/asset/asset', () => ({
assetService: {
createVersion: vi
.fn()
.mockResolvedValue({ id: 'file-1', name: 'v2', type: 'file', sizeByte: 100 }),
},
}))
describe('createCreateVersionTool', () => {
@@ -41,7 +54,7 @@ describe('createCreateVersionTool', () => {
return filePath
}
it('should upload a local file and create a version via the agent tool workflow', async () => {
it('should upload a local file and create a version via assetService.createVersion', async () => {
const filePath = createTempFile('# Hello from disk', 'create-version-test.md')
const tool = createCreateVersionTool('user-1')
@@ -53,23 +66,27 @@ describe('createCreateVersionTool', () => {
expect(s3Key).toMatch(/^files\/.+\.md$/)
expect(uploadArgs[2]).toBe('text/markdown')
expect(executeAgentToolWorkflow).toHaveBeenCalledWith({
toolName: 'create_version',
args: {
parent: 'file-1',
s3Key,
name: 'create-version-test.md',
size: Buffer.byteLength('# Hello from disk', 'utf-8'),
contentType: 'text/markdown',
},
userId: 'user-1',
assetId: 'file-1',
expect(authzService.hasPermission).toHaveBeenCalledWith({
user: { id: 'user-1' },
permission: 'edit',
type: 'asset',
id: 'file-1',
})
expect(result.details).toEqual({ id: 'file-1', name: 'v2', type: 'file' })
expect(assetService.createVersion).toHaveBeenCalledWith({
parentId: 'file-1',
name: 'create-version-test.md',
key: s3Key,
sizeByte: Buffer.byteLength('# Hello from disk', 'utf-8'),
contentType: 'text/markdown',
creatorId: 'user-1',
metadata: undefined,
})
expect(result.details).toEqual({ id: 'file-1', name: 'v2', type: 'file', size: 100 })
})
it('should forward the metadata to the agent tool workflow when provided', async () => {
it('should forward the metadata to assetService.createVersion when provided', async () => {
const filePath = createTempFile('# Hello from disk', 'create-version-metadata.md')
const metadataSchema = fieldsToTypeBoxSchema([
{ id: 'prompt', config: { name: 'Prompt', type: 'text' } },
@@ -82,9 +99,9 @@ describe('createCreateVersionTool', () => {
metadata: { prompt: 'Generated using gemini' },
})
expect(executeAgentToolWorkflow).toHaveBeenCalledWith(
expect(assetService.createVersion).toHaveBeenCalledWith(
expect.objectContaining({
args: expect.objectContaining({ metadata: { prompt: 'Generated using gemini' } }),
metadata: { prompt: 'Generated using gemini' },
}),
)
})
@@ -120,19 +137,17 @@ describe('createCreateVersionTool', () => {
},
})
expect(executeAgentToolWorkflow).toHaveBeenCalledWith(
expect(assetService.createVersion).toHaveBeenCalledWith(
expect.objectContaining({
args: expect.objectContaining({
metadata: {
provider: { newOption: { value: 'Kling' } },
tags: ['tag1', { newOption: { value: 'Tag 2' } }],
},
}),
metadata: {
provider: { newOption: { value: 'Kling' } },
tags: ['tag1', { newOption: { value: 'Tag 2' } }],
},
}),
)
})
it('should not include metadata in args when metadata is null', async () => {
it('should not include metadata when metadata is null', async () => {
const filePath = createTempFile('# Hello from disk', 'create-version-no-metadata.md')
const metadataSchema = fieldsToTypeBoxSchema([
{ id: 'prompt', config: { name: 'Prompt', type: 'text' } },
@@ -141,8 +156,8 @@ describe('createCreateVersionTool', () => {
const tool = createCreateVersionTool('user-1', metadataSchema)
await tool.execute('call-1', { parent: 'file-1', path: filePath, metadata: null })
const callArgs = vi.mocked(executeAgentToolWorkflow).mock.calls[0][0].args
expect(callArgs).not.toHaveProperty('metadata')
const callArgs = vi.mocked(assetService.createVersion).mock.calls[0][0]
expect(callArgs.metadata).toBeUndefined()
})
it('should throw when the local file does not exist', async () => {
@@ -151,7 +166,7 @@ describe('createCreateVersionTool', () => {
tool.execute('call-1', { parent: 'file-1', path: '/nonexistent/file.md' }),
).rejects.toThrow('Local file not found at path: /nonexistent/file.md')
expect(s3Service.uploadFileToKey).not.toHaveBeenCalled()
expect(executeAgentToolWorkflow).not.toHaveBeenCalled()
expect(assetService.createVersion).not.toHaveBeenCalled()
})
it('should expose a strict, all-required (nullable) metadata schema when fields are provided', () => {
+32 -18
View File
@@ -1,12 +1,14 @@
import { Type, type TSchema } from 'typebox'
import { type AgentTool } from '@earendil-works/pi-agent-core'
import { executeAgentToolWorkflow } from './utils'
import * as fs from 'fs'
import * as path from 'path'
import { assetService } from '@shumai/core/src/asset/asset'
import { authzService, Permission, ResourceType } from '@shumai/core/src/authz/authz'
import { s3Service } from '@shumai/core/src/s3/s3'
import { readFileMimeType } from '@shumai/core/src/utils/file-mime'
import { ulid } from 'ulid'
import { sanitizeFilename } from '@shumai/core/src/utils/filename'
import { type User } from '@shumai/db'
import { Type, type TSchema } from 'typebox'
import * as fs from 'fs'
import * as path from 'path'
import { ulid } from 'ulid'
interface CreateVersionToolParams {
parent: string
@@ -48,24 +50,36 @@ export function createCreateVersionTool(userId: string, metadataSchema?: TSchema
const fileSize = fs.statSync(absolutePath).size
const mimeType = readFileMimeType(absolutePath)
const name = path.basename(absolutePath)
// Generate compliant S3 key matching normal file upload format
const s3Key = `files/${ulid()}/${sanitizeFilename(path.basename(absolutePath))}`
const s3Key = `files/${ulid()}/${sanitizeFilename(name)}`
await s3Service.uploadFileToKey(absolutePath, s3Key, mimeType)
const result = await executeAgentToolWorkflow({
toolName: 'create_version',
args: {
parent: p.parent,
s3Key,
name: path.basename(absolutePath),
size: fileSize,
contentType: mimeType,
...(p.metadata ? { metadata: p.metadata } : {}),
},
userId,
assetId: p.parent,
await authzService.hasPermission({
user: { id: userId } as User,
permission: Permission.Edit,
type: ResourceType.Asset,
id: p.parent,
})
const asset = await assetService.createVersion({
parentId: p.parent,
name,
key: s3Key,
sizeByte: fileSize,
contentType: mimeType,
creatorId: userId,
metadata: p.metadata ?? undefined,
})
const result = {
id: asset.id,
name: asset.name,
type: asset.type,
size: Number(asset.sizeByte),
}
return {
content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
details: result,
@@ -0,0 +1,78 @@
import { describe, it, expect, vi, beforeEach } from 'vitest'
import { createListAssetsTool } from './list-assets'
import { assetService } from '@shumai/core/src/asset/asset'
import { authzService } from '@shumai/core/src/authz/authz'
vi.mock('@shumai/core/src/authz/authz', () => ({
authzService: {
hasPermission: vi.fn().mockResolvedValue(undefined),
},
Permission: { Edit: 'edit', Read: 'read' },
ResourceType: { Asset: 'asset' },
}))
vi.mock('@shumai/core/src/asset/asset', () => ({
assetService: {
listChildren: vi.fn().mockResolvedValue({
data: [
{ id: '01M2FILE2', name: 'file2.txt', type: 'file', sizeByte: 200 },
{ id: '01M1FILE1', name: 'file1.txt', type: 'file', sizeByte: 100 },
],
pageInfo: { hasNextPage: false, hasPreviousPage: false, cursor: 'abc' },
}),
},
}))
describe('createListAssetsTool', () => {
beforeEach(() => {
vi.clearAllMocks()
})
it('checks read permissions and invokes assetService.listChildren with default all and id desc ordering', async () => {
const tool = createListAssetsTool('user-1')
const result = await tool.execute('call-1', { parent: 'folder-1' })
expect(authzService.hasPermission).toHaveBeenCalledWith({
user: { id: 'user-1' },
permission: 'read',
type: 'asset',
id: 'folder-1',
})
expect(assetService.listChildren).toHaveBeenCalledWith({
assetId: 'folder-1',
assetType: 'all',
sort: 'createdAt',
order: 'desc',
first: 20,
after: undefined,
})
expect(result.details).toEqual({
assets: [
{ id: '01M2FILE2', name: 'file2.txt', type: 'file', size: 200 },
{ id: '01M1FILE1', name: 'file1.txt', type: 'file', size: 100 },
],
pageInfo: { hasNextPage: false, hasPreviousPage: false, cursor: 'abc' },
})
})
it('passes explicit pagination and type filter options to assetService.listChildren', async () => {
const tool = createListAssetsTool('user-1')
await tool.execute('call-1', {
parent: 'folder-1',
page: 2,
pageSize: 10,
type: 'folder',
})
expect(assetService.listChildren).toHaveBeenCalledWith({
assetId: 'folder-1',
assetType: 'folder',
sort: 'createdAt',
order: 'desc',
first: 10,
after: expect.any(String),
})
})
})
+38 -10
View File
@@ -1,6 +1,9 @@
import { Type } from 'typebox'
import { type AgentTool } from '@earendil-works/pi-agent-core'
import { executeAgentToolWorkflow } from './utils'
import { assetService } from '@shumai/core/src/asset/asset'
import { authzService, Permission, ResourceType } from '@shumai/core/src/authz/authz'
import { encodeCursor } from '@shumai/core/src/pagination'
import { type User } from '@shumai/db'
const listAssetsSchema = Type.Object({
parent: Type.String({
@@ -19,9 +22,8 @@ const listAssetsSchema = Type.Object({
}),
),
type: Type.Optional(
Type.String({
Type.Union([Type.Literal('file'), Type.Literal('folder'), Type.Literal('all')], {
description: "Filter assets by type: 'file', 'folder', or 'all'. Default is 'all'.",
enum: ['file', 'folder', 'all'],
default: 'all',
}),
),
@@ -34,15 +36,41 @@ export function createListAssetsTool(userId: string): AgentTool<typeof listAsset
description: 'List the assets (files and folders) inside a parent folder with pagination.',
parameters: listAssetsSchema,
execute: async (_toolCallId, params) => {
const result = await executeAgentToolWorkflow({
toolName: 'list_assets',
args: params,
userId,
assetId: params.parent,
await authzService.hasPermission({
user: { id: userId } as User,
permission: Permission.Read,
type: ResourceType.Asset,
id: params.parent,
})
const page = params.page || 1
const pageSize = params.pageSize || 20
const type = params.type || 'all'
const result = await assetService.listChildren({
assetId: params.parent,
assetType: type,
sort: 'createdAt',
order: 'desc',
first: pageSize,
after: page > 1 ? encodeCursor((page - 1) * pageSize) : undefined,
})
const assets = result.data.map((a) => ({
id: a.id,
name: a.name,
type: a.type,
size: Number(a.sizeByte),
}))
const output = {
assets,
pageInfo: result.pageInfo,
}
return {
content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
details: result,
content: [{ type: 'text', text: JSON.stringify(output, null, 2) }],
details: output,
}
},
}
-35
View File
@@ -1,35 +0,0 @@
import { prisma } from '@shumai/db'
import { workflowService } from '@shumai/workflow-core'
import { WorkflowTaskType, WorkflowTaskStatus } from '@shumai/db'
export async function executeAgentToolWorkflow(params: {
toolName: string
args: Record<string, unknown>
userId: string
assetId: string
}): Promise<unknown> {
const task = await prisma.workflowTask.create({
data: {
type: WorkflowTaskType.agent_tool_call,
status: WorkflowTaskStatus.pending,
assetId: params.assetId,
payload: {
projectId: 'none',
agentToolCall: {
toolName: params.toolName,
args: params.args,
userId: params.userId,
},
},
},
})
const completedTask = await workflowService.executeWait(task)
if (completedTask.status === WorkflowTaskStatus.failed) {
const output = completedTask.output as Record<string, unknown> | null
const errorMsg = (output?.error as string) || 'Workflow task failed'
throw new Error(errorMsg)
}
return completedTask.output
}
@@ -1,171 +0,0 @@
import { describe, it, expect } from 'vitest'
import { AgentChatPromptBuilder } from './agent-chat-prompt-builder'
describe('AgentChatPromptBuilder', () => {
it('should build prompt with baseline configurations', () => {
const builder = new AgentChatPromptBuilder('a1')
const result = builder.build()
expect(result).toContain('The user is discussing an asset with ID: a1.')
})
it('should build prompt with path context', () => {
const builder = new AgentChatPromptBuilder('a1').withPathContext('folder/sub/file.png')
const result = builder.build()
expect(result).toContain('Asset Path Context:\nfolder/sub/file.png')
})
it('should build prompt with image asset details', () => {
const builder = new AgentChatPromptBuilder('a1').withAssetDetails(
'test.png',
'image/png',
undefined,
undefined,
'image',
)
const result = builder.build()
expect(result).toContain('File Name: test.png')
expect(result).toContain('File Type: image')
expect(result).toContain("call the 'analyze_image' tool")
expect(result).not.toContain("call the 'screenshot' tool")
})
it('should build prompt with video asset details and duration', () => {
const builder = new AgentChatPromptBuilder('a1').withAssetDetails(
'movie.mp4',
'video/mp4',
12.34,
undefined,
'video',
)
const result = builder.build()
expect(result).toContain('File Name: movie.mp4')
expect(result).toContain('File Type: video')
expect(result).toContain('Video Length: 12.34 seconds')
expect(result).toContain("call the 'screenshot' tool")
expect(result).not.toContain("call the 'analyze_image' tool")
})
it('should build prompt with PDF asset details and total pages', () => {
const builder = new AgentChatPromptBuilder('a1').withAssetDetails(
'doc.pdf',
'application/pdf',
undefined,
15,
'pdf',
)
const result = builder.build()
expect(result).toContain('File Name: doc.pdf')
expect(result).toContain('File Type: pdf')
expect(result).toContain('Total Pages: 15')
expect(result).toContain("call the 'read_pdf_pages' tool")
expect(result).toContain('Maximum 20 pages allowed per call.')
expect(result).not.toContain("call the 'screenshot' tool")
expect(result).not.toContain("call the 'analyze_image' tool")
})
it('should build prompt with comment page for PDF asset', () => {
const builder = new AgentChatPromptBuilder('a1')
.withAssetDetails('doc.pdf', 'application/pdf', undefined, 10, 'pdf')
.withCommentTimestamp(3)
const result = builder.build()
expect(result).toContain('Comment Page: 3')
})
it('should build prompt for PDF continuation mode with comment page', () => {
const builder = new AgentChatPromptBuilder('a1')
.withContinuation(true)
.withAssetDetails('doc.pdf', 'application/pdf', undefined, 10, 'pdf')
.withCommentTimestamp(4)
const result = builder.build()
expect(result).toContain('Comment Page: 4')
expect(result).not.toContain('Comment Timestamp:')
})
it('should build prompt with comment timestamp', () => {
const builder = new AgentChatPromptBuilder('a1').withCommentTimestamp(5.5)
const result = builder.build()
expect(result).toContain('Comment Timestamp: 5.50 seconds')
})
it('should build prompt with all fields combined', () => {
const builder = new AgentChatPromptBuilder('a1')
.withPathContext('src/main.ts')
.withAssetDetails('movie.mp4', 'video/mp4', 12.34, undefined, 'video')
.withCommentTimestamp(8.2)
const result = builder.build()
expect(result).toContain('The user is discussing an asset with ID: a1.')
expect(result).toContain('File Name: movie.mp4')
expect(result).toContain('File Type: video')
expect(result).toContain('Video Length: 12.34 seconds')
expect(result).toContain('Comment Timestamp: 8.20 seconds')
expect(result).toContain('Asset Path Context:\nsrc/main.ts')
expect(result).toContain("call the 'screenshot' tool")
})
it('should build prompt with attached files and referenced assets', () => {
const builder = new AgentChatPromptBuilder('a1')
.withAttachedFiles(['- file1.txt', '- file2.png'])
.withReferencedAssets(['- folder1', '- file3.mp4'])
const result = builder.build()
expect(result).toContain('[Context: Attached Files & Referenced Assets]')
expect(result).toContain('Attached Files:\n- file1.txt\n- file2.png')
expect(result).toContain('Referenced Workspace Assets:\n- folder1\n- file3.mp4')
})
it('should build prompt for continuation mode returning only turn-specific modifications', () => {
const builder = new AgentChatPromptBuilder('a1')
.withContinuation(true)
.withAssetDetails('movie.mp4', 'video/mp4', 12.34)
.withPathContext('src/main.ts')
.withCommentTimestamp(8.2)
.withAttachedFiles(['- file1.txt'])
.withReferencedAssets(['- folder1'])
const result = builder.build()
expect(result).not.toContain('The user is discussing an asset with ID:')
expect(result).not.toContain('File Name: movie.mp4')
expect(result).not.toContain('Asset Path Context:')
expect(result).toContain('Comment Timestamp: 8.20 seconds')
expect(result).toContain('[Context: New Attached Files & Referenced Assets]')
expect(result).toContain('Attached Files:\n- file1.txt')
expect(result).toContain('Referenced Workspace Assets:\n- folder1')
})
it('should include location change context block in continuation mode when asset has changed', () => {
const builder = new AgentChatPromptBuilder('a2')
.withContinuation(true)
.withAssetChanged(true)
.withAssetDetails('new-folder', 'folder', undefined, undefined, 'folder')
.withPathContext('projects/my-proj/new-folder')
const result = builder.build()
expect(result).toContain('[Context: User Navigated to a New Location]')
expect(result).toContain('New Location Asset ID: a2')
expect(result).toContain('File Name: new-folder')
expect(result).toContain('Asset Path Context:\nprojects/my-proj/new-folder')
})
it('should build prompt with user info when provided and not continuation', () => {
const builder = new AgentChatPromptBuilder('a1').withUserInfo('Alice', 'owner')
const result = builder.build()
expect(result).toContain('User Info:\nName: Alice\nRole: owner')
})
it('should build prompt with download_asset tool instruction', () => {
const builder = new AgentChatPromptBuilder('a1')
const result = builder.build()
expect(result).toContain("call the 'download_asset' tool with assetId.")
})
})
@@ -1,185 +0,0 @@
export function getSimpleMediaType(proxyType?: string | null): 'image' | 'video' | 'pdf' | 'other' {
if (proxyType === 'image') return 'image'
if (proxyType === 'video') return 'video'
if (proxyType === 'pdf') return 'pdf'
return 'other'
}
export class AgentChatPromptBuilder {
private assetId: string
private assetName?: string
private mediaType?: string
private proxyType?: string
private videoDuration?: number
private totalPages?: number
private commentTimestamp?: number
private pathContext?: string
private attachedFiles: string[] = []
private referencedAssets: string[] = []
private userInfo?: { name: string; role: string }
private isContinuation = false
private hasAssetChanged = false
constructor(assetId: string) {
this.assetId = assetId
}
withUserInfo(name?: string, role?: string): this {
if (name) {
this.userInfo = { name, role: role || 'user' }
}
return this
}
withContinuation(isContinuation: boolean): this {
this.isContinuation = isContinuation
return this
}
withAssetChanged(hasAssetChanged?: boolean): this {
this.hasAssetChanged = !!hasAssetChanged
return this
}
withAttachedFiles(files?: string[]): this {
if (files) {
this.attachedFiles = files
}
return this
}
withReferencedAssets(assets?: string[]): this {
if (assets) {
this.referencedAssets = assets
}
return this
}
withPathContext(pathContext?: string): this {
this.pathContext = pathContext
return this
}
withAssetDetails(
name: string,
mediaType: string | null,
duration?: number,
totalPages?: number,
proxyType?: string | null,
): this {
this.assetName = name
this.mediaType = mediaType || undefined
this.proxyType = proxyType || undefined
this.videoDuration = duration
this.totalPages = totalPages
return this
}
withCommentTimestamp(second?: number | null): this {
if (second !== undefined && second !== null) {
this.commentTimestamp = second
}
return this
}
build(): string {
const effectiveType = this.proxyType
if (this.isContinuation) {
let instruction = ''
if (this.hasAssetChanged) {
instruction += `[Context: User Navigated to a New Location]\nNew Location Asset ID: ${this.assetId}`
if (this.assetName) {
instruction += `\nFile Name: ${this.assetName}`
}
if (effectiveType) {
const type = getSimpleMediaType(effectiveType)
instruction += `\nFile Type: ${type}`
if (type === 'video' && this.videoDuration !== undefined) {
instruction += `\nVideo Length: ${this.videoDuration.toFixed(2)} seconds`
} else if (type === 'pdf' && this.totalPages !== undefined) {
instruction += `\nTotal Pages: ${this.totalPages}`
}
}
if (this.pathContext) {
instruction += `\n\nAsset Path Context:\n${this.pathContext}`
}
}
if (this.commentTimestamp !== undefined) {
const type = getSimpleMediaType(effectiveType)
if (instruction) instruction += '\n\n'
if (type === 'pdf') {
instruction += `Comment Page: ${Math.round(this.commentTimestamp)}`
} else {
instruction += `Comment Timestamp: ${this.commentTimestamp.toFixed(2)} seconds`
}
}
if (this.attachedFiles.length > 0 || this.referencedAssets.length > 0) {
if (instruction) instruction += '\n\n'
instruction += `[Context: New Attached Files & Referenced Assets]`
if (this.attachedFiles.length > 0) {
instruction += `\nAttached Files:\n${this.attachedFiles.join('\n')}`
}
if (this.referencedAssets.length > 0) {
instruction += `\nReferenced Workspace Assets:\n${this.referencedAssets.join('\n')}`
}
}
return instruction.trim()
}
let instruction = `The user is discussing an asset with ID: ${this.assetId}.`
if (this.assetName) {
instruction += `\nFile Name: ${this.assetName}`
}
if (effectiveType) {
const type = getSimpleMediaType(effectiveType)
instruction += `\nFile Type: ${type}`
if (type === 'video' && this.videoDuration !== undefined) {
instruction += `\nVideo Length: ${this.videoDuration.toFixed(2)} seconds`
} else if (type === 'pdf' && this.totalPages !== undefined) {
instruction += `\nTotal Pages: ${this.totalPages}`
}
}
if (this.commentTimestamp !== undefined) {
const type = getSimpleMediaType(effectiveType)
if (type === 'pdf') {
instruction += `\nComment Page: ${Math.round(this.commentTimestamp)}`
} else {
instruction += `\nComment Timestamp: ${this.commentTimestamp.toFixed(2)} seconds`
}
}
if (this.pathContext) {
instruction += `\n\nAsset Path Context:\n${this.pathContext}`
}
if (this.attachedFiles.length > 0 || this.referencedAssets.length > 0) {
instruction += `\n\n[Context: Attached Files & Referenced Assets]`
if (this.attachedFiles.length > 0) {
instruction += `\nAttached Files:\n${this.attachedFiles.join('\n')}`
}
if (this.referencedAssets.length > 0) {
instruction += `\nReferenced Workspace Assets:\n${this.referencedAssets.join('\n')}`
}
}
if (effectiveType) {
const type = getSimpleMediaType(effectiveType)
if (type === 'image') {
instruction += `\n\nIf you need to view the image data, call the 'analyze_image' tool with assetId "${this.assetId}".`
} else if (type === 'video') {
instruction += `\n\nIf you need to view visual frames or take screenshots of the video, call the 'screenshot' tool. You must specify the 'start' (seconds), 'end' (seconds), and 'count' (number of screenshots) parameters.`
} else if (type === 'pdf') {
instruction += `\n\nIf you need to view pages of the PDF document, call the 'read_pdf_pages' tool. You must specify the 'start' (page number) and 'end' (page number) parameters. Maximum 20 pages allowed per call.`
}
}
instruction += `\n\nIf you need a local file on disk to run bash commands or scripts (e.g. processing or combining assets), call the 'download_asset' tool with assetId.`
if (this.userInfo) {
instruction += `\n\nUser Info:\nName: ${this.userInfo.name}\nRole: ${this.userInfo.role}`
}
return instruction
}
}
+233 -59
View File
@@ -3,7 +3,6 @@ import { agentChat } from './agent-chat'
import { prisma } from '@shumai/db'
import { setupTestDbHooks } from '@shumai/db/test'
import * as workflowUtils from '@shumai/workflow-core'
import { AgentChatPromptBuilder } from './agent-chat-prompt-builder'
vi.mock('@shumai/workflow-core', async () => {
const actual = await vi.importActual('@shumai/workflow-core')
@@ -43,6 +42,9 @@ describe('Agent Chat Workflow', () => {
updateCommentActivity: Object.assign(vi.fn(), { _activityName: 'updateCommentActivity' }),
updateTaskUsageActivity: Object.assign(vi.fn(), { _activityName: 'updateTaskUsageActivity' }),
deleteCommentActivity: Object.assign(vi.fn(), { _activityName: 'deleteCommentActivity' }),
getAssetPathHierarchyActivity: Object.assign(vi.fn(), {
_activityName: 'getAssetPathHierarchyActivity',
}),
getAssetPathContextActivity: Object.assign(vi.fn(), {
_activityName: 'getAssetPathContextActivity',
}),
@@ -70,13 +72,21 @@ describe('Agent Chat Workflow', () => {
})
mockActivities.getCommentActivity.mockResolvedValue({
id: 'c1',
creatorId: 'user-c1',
message: 'hello agent',
replyToId: null,
attachments: [],
})
mockActivities.initializeAgentSessionActivity.mockResolvedValue('session-123')
mockActivities.getAgentChatContextActivity.mockResolvedValue({ agent: { id: 'b1' } })
mockActivities.getAssetPathContextActivity.mockResolvedValue('Path: folder/subfolder/file.png')
mockActivities.getAssetPathHierarchyActivity.mockResolvedValue({
path: 'folder/subfolder/test-file.png',
ancestors: [
{ id: 'f1', name: 'folder' },
{ id: 'f2', name: 'subfolder' },
],
})
mockActivities.getAssetPathContextActivity.mockResolvedValue('folder/subfolder/test-file.png')
mockActivities.agentChatActivity.mockResolvedValue({
text: 'Hello user, how can I help you?',
sessionId: 'session-123',
@@ -119,7 +129,6 @@ describe('Agent Chat Workflow', () => {
expect(mockActivities.getCommentActivity).toHaveBeenCalledWith('c1')
// Verify agent context fetched with the project context forwarded
// (required for project-aware role enforcement in the activity)
expect(mockActivities.getAgentChatContextActivity).toHaveBeenCalledWith({
teamId: 't1',
agentId: 'b1',
@@ -144,22 +153,31 @@ describe('Agent Chat Workflow', () => {
userId: undefined,
})
// Verify agent instruction composition
const expectedInstruction1 = new AgentChatPromptBuilder('a1')
.withPathContext('Path: folder/subfolder/file.png')
.withAssetDetails('test-file.png', 'image/png', undefined, undefined, 'image')
.withCommentTimestamp(null)
.build()
// Verify agent chat called with structured messageContext
expect(mockActivities.agentChatActivity).toHaveBeenCalledWith(
expect.objectContaining({
teamId: 't1',
agentId: 'b1',
message: 'hello agent',
agentsInstruction: expectedInstruction1,
sessionId: 'session-123',
folderId: 'parent-folder-id',
assetId: 'a1',
messageContext: expect.objectContaining({
user: { id: 'user-c1', name: 'Test User', role: 'owner' },
currentAsset: expect.objectContaining({
id: 'a1',
name: 'test-file.png',
type: 'file',
mediaType: 'image',
mimeType: 'image/png',
parentId: 'parent-folder-id',
path: 'folder/subfolder/test-file.png',
ancestors: [
{ id: 'f1', name: 'folder' },
{ id: 'f2', name: 'subfolder' },
],
}),
}),
}),
)
@@ -211,17 +229,13 @@ describe('Agent Chat Workflow', () => {
await agentChat(task)
expect(mockActivities.initializeAgentSessionActivity).not.toHaveBeenCalled()
const expectedInstruction2 = new AgentChatPromptBuilder('a1')
.withContinuation(true)
.withPathContext('Path: folder/subfolder/file.png')
.withAssetDetails('test-file.png', 'image/png', undefined)
.withCommentTimestamp(null)
.build()
expect(mockActivities.agentChatActivity).toHaveBeenCalledWith(
expect.objectContaining({
sessionId: 'existing-session-456',
agentsInstruction: expectedInstruction2,
messageContext: expect.objectContaining({
currentAsset: expect.objectContaining({ id: 'a1', name: 'test-file.png' }),
}),
}),
)
@@ -273,16 +287,9 @@ describe('Agent Chat Workflow', () => {
await agentChat(task)
const expectedInstruction4 = new AgentChatPromptBuilder('a1')
.withPathContext('Path: folder/subfolder/file.png')
.withAssetDetails('test-file.png', 'image/png', undefined, undefined, 'image')
.withCommentTimestamp(null)
.build()
expect(mockActivities.agentChatActivity).toHaveBeenCalledWith(
expect.objectContaining({
imageUrls: ['attachments/image1.png', 'attachments/image2.jpg'],
agentsInstruction: expectedInstruction4,
}),
)
})
@@ -315,15 +322,13 @@ describe('Agent Chat Workflow', () => {
await agentChat(task)
const expectedInstruction5 = new AgentChatPromptBuilder('a1')
.withPathContext('Path: folder/subfolder/file.png')
.withAssetDetails('test-asset', 'video/mp4', 10)
.withCommentTimestamp(null)
.build()
expect(mockActivities.agentChatActivity).toHaveBeenCalledWith(
expect.objectContaining({
agentsInstruction: expectedInstruction5,
messageContext: expect.objectContaining({
currentAsset: expect.objectContaining({
durationSeconds: 10,
}),
}),
}),
)
})
@@ -391,6 +396,7 @@ describe('Agent Chat Workflow', () => {
name: 'attachment.png',
type: 'file',
mediaType: 'image/png',
media: { proxyType: 'image' },
projectId: 'p1',
}
}
@@ -400,6 +406,7 @@ describe('Agent Chat Workflow', () => {
name: 'ref-folder',
type: 'folder',
mediaType: null,
media: null,
projectId: 'p1',
}
}
@@ -408,6 +415,7 @@ describe('Agent Chat Workflow', () => {
name: 'test-file.png',
type: 'file',
mediaType: 'image/png',
media: { proxyType: 'image' },
projectId: 'p1',
project: { teamId: 't1' },
}
@@ -443,20 +451,7 @@ describe('Agent Chat Workflow', () => {
expect(mockActivities.createCommentActivity).not.toHaveBeenCalled()
expect(mockActivities.updateCommentActivity).not.toHaveBeenCalled()
// Verify prompt builder is populated and workflow runs agentChatActivity with context instruction
const expectedInstruction = new AgentChatPromptBuilder('a1')
.withContinuation(true)
.withPathContext('folder/subfolder/file.png')
.withAssetDetails('test-file.png', 'image/png', undefined)
.withCommentTimestamp(undefined)
.withAttachedFiles([
'- Name: attachment.png (ID: file-attachment-1, Type: file, Media Type: image/png, Project ID: p1, Path: attachment.png)',
])
.withReferencedAssets([
'- Name: ref-folder (ID: referenced-asset-1, Type: folder, Media Type: unknown, Project ID: p1, Path: ref-folder)',
])
.build()
// Verify messageContext is populated with attachedFiles and referencedAssets
expect(mockActivities.agentChatActivity).toHaveBeenCalledWith(
expect.objectContaining({
teamId: 't1',
@@ -465,15 +460,32 @@ describe('Agent Chat Workflow', () => {
imageUrls: [],
projectId: 'p1',
folderId: '',
agentsInstruction: expectedInstruction,
sessionId: 'session-direct-123',
userId: undefined,
userCommentId: undefined,
context: { agent: { id: 'b1' } },
attachedAssets: [
{ id: 'file-attachment-1', name: 'attachment.png', type: 'file' },
{ id: 'referenced-asset-1', name: 'ref-folder', type: 'folder' },
],
messageContext: expect.objectContaining({
attachedFiles: [
{
id: 'file-attachment-1',
name: 'attachment.png',
type: 'file',
mediaType: 'image',
mimeType: 'image/png',
path: 'attachment.png',
},
],
referencedAssets: [
{
id: 'referenced-asset-1',
name: 'ref-folder',
type: 'folder',
mediaType: undefined,
mimeType: undefined,
path: 'ref-folder',
},
],
}),
}),
)
})
@@ -512,19 +524,18 @@ describe('Agent Chat Workflow', () => {
await agentChat(task)
const expectedInstruction = new AgentChatPromptBuilder('v2-latest')
.withContinuation(true)
.withPathContext('Path: folder/subfolder/file.png')
.withAssetDetails('latest-video.mp4', 'video/mp4', 42, undefined, 'video')
.build()
expect(mockActivities.agentChatActivity).toHaveBeenCalledWith(
expect.objectContaining({
teamId: 't1',
agentId: 'b1',
message: 'Explain this version stack video',
agentsInstruction: expectedInstruction,
sessionId: 'session-vs-123',
messageContext: expect.objectContaining({
currentAsset: expect.objectContaining({
id: 'v2-latest',
durationSeconds: 42,
}),
}),
}),
)
})
@@ -557,7 +568,170 @@ describe('Agent Chat Workflow', () => {
expect(mockActivities.agentChatActivity).toHaveBeenCalledWith(
expect.objectContaining({
agentsInstruction: expect.stringContaining('User Info:\nName: Test User\nRole: owner'),
messageContext: expect.objectContaining({
user: { id: 'user-alice', name: 'Test User', role: 'owner' },
}),
}),
)
})
it('should populate comment attachments into structured messageContext.attachedFiles', async () => {
mockActivities.getCommentActivity.mockResolvedValue({
id: 'c1',
creatorId: 'user-c1',
message: 'check these attachments',
replyToId: null,
attachments: [
{
asset: {
id: 'att-doc-1',
name: 'brief.pdf',
type: 'file',
mediaType: 'application/pdf',
media: { proxyType: 'pdf' },
storageKey: { key: 'brief.pdf' },
},
},
{
asset: {
id: 'att-img-1',
name: 'mockup.png',
type: 'file',
mediaType: 'image/png',
media: { proxyType: 'image' },
storageKey: { key: 'mockup.png' },
},
},
],
})
mockActivities.getAssetPathContextActivity.mockImplementation(async (id: string) => {
if (id === 'att-doc-1') return 'Docs/brief.pdf'
if (id === 'att-img-1') return 'Designs/mockup.png'
return 'folder/subfolder/file.png'
})
const task = await prisma.workflowTask.create({
data: {
type: 'chat',
status: 'pending',
assetId: 'a1',
payload: {
projectId: 'p1',
agent: { userCommentId: 'c1', agentId: 'b1' },
},
},
})
await agentChat(task)
expect(mockActivities.agentChatActivity).toHaveBeenCalledWith(
expect.objectContaining({
imageUrls: ['mockup.png'],
messageContext: expect.objectContaining({
attachedFiles: [
{
id: 'att-doc-1',
name: 'brief.pdf',
type: 'file',
mediaType: 'pdf',
mimeType: 'application/pdf',
path: 'Docs/brief.pdf',
},
{
id: 'att-img-1',
name: 'mockup.png',
type: 'file',
mediaType: 'image',
mimeType: 'image/png',
path: 'Designs/mockup.png',
},
],
}),
}),
)
})
it('should set totalFrames for video assets and totalPages for pdf assets in currentAsset context', async () => {
mockActivities.getAssetActivity.mockImplementation(async (id: string) => {
if (id === 'video-asset-1') {
return {
id: 'video-asset-1',
project: { teamId: 't1' },
type: 'file',
name: 'clip.mp4',
mediaType: 'video/mp4',
media: { proxyType: 'video', duration: 9, frames: 268 },
parentId: 'f1',
}
}
if (id === 'pdf-asset-1') {
return {
id: 'pdf-asset-1',
project: { teamId: 't1' },
type: 'file',
name: 'doc.pdf',
mediaType: 'application/pdf',
media: { proxyType: 'pdf', frames: 15, duration: 0 },
parentId: 'f1',
}
}
return null
})
// Test Video asset
const videoTask = await prisma.workflowTask.create({
data: {
type: 'chat',
status: 'pending',
assetId: 'video-asset-1',
payload: {
projectId: 'p1',
agent: { prompt: 'Analyze video', agentId: 'b1', sessionId: 'session-video-1' },
},
},
})
await agentChat(videoTask)
expect(mockActivities.agentChatActivity).toHaveBeenCalledWith(
expect.objectContaining({
messageContext: expect.objectContaining({
currentAsset: expect.objectContaining({
id: 'video-asset-1',
mediaType: 'video',
durationSeconds: 9,
totalFrames: 268,
totalPages: undefined,
}),
}),
}),
)
// Test PDF asset
const pdfTask = await prisma.workflowTask.create({
data: {
type: 'chat',
status: 'pending',
assetId: 'pdf-asset-1',
payload: {
projectId: 'p1',
agent: { prompt: 'Analyze pdf', agentId: 'b1', sessionId: 'session-pdf-1' },
},
},
})
await agentChat(pdfTask)
expect(mockActivities.agentChatActivity).toHaveBeenCalledWith(
expect.objectContaining({
messageContext: expect.objectContaining({
currentAsset: expect.objectContaining({
id: 'pdf-asset-1',
mediaType: 'pdf',
totalPages: 15,
totalFrames: undefined,
durationSeconds: undefined,
}),
}),
}),
)
})
+135 -32
View File
@@ -1,7 +1,13 @@
import { ApplicationFailure } from '@temporalio/workflow'
import type { WorkflowTask } from '@shumai/db'
import { executeActivity, getActivities, TaskQueueAgent } from '@shumai/workflow-core'
import { AgentChatPromptBuilder } from './agent-chat-prompt-builder'
import type {
ShumaiMessageContext,
ShumaiAssetContext,
ShumaiAttachedFileContext,
ShumaiMediaPosition,
} from '@shumai/dtos'
import { getProxyType } from '@shumai/core/src/utils/mime'
export async function agentChat(task: WorkflowTask): Promise<void> {
const {
@@ -15,6 +21,7 @@ export async function agentChat(task: WorkflowTask): Promise<void> {
updateTaskUsageActivity,
getAgentWorkerQueueActivity,
initializeAgentSessionActivity,
getAssetPathHierarchyActivity,
getAssetPathContextActivity,
generateSessionNameActivity,
getUserTeamInfoActivity,
@@ -47,19 +54,30 @@ export async function agentChat(task: WorkflowTask): Promise<void> {
// 1. Get User Comment
const userCommentId = payload.agent?.userCommentId
let userComment: Awaited<ReturnType<typeof getCommentActivity>> | null = null
let prompt = ''
let attachmentImageUrls: string[] = []
let commentTimestamp: number | undefined
let commentAnnotation = false
let commentCreatorId: string | undefined
if (userCommentId) {
const userComment = await executeActivity(agentWorkerQueue, getCommentActivity, userCommentId)
userComment = await executeActivity(agentWorkerQueue, getCommentActivity, userCommentId)
if (!userComment) {
throw ApplicationFailure.create({ message: 'User comment not found', nonRetryable: true })
}
prompt = userComment.message || ''
commentCreatorId = userComment.creatorId || undefined
if (userComment.second !== null && userComment.second !== undefined) {
commentTimestamp = userComment.second
}
if (
userComment.annotation &&
Array.isArray(userComment.annotation) &&
userComment.annotation.length > 0
) {
commentAnnotation = true
}
// 2. Create Placeholder Comment
const placeholder = await executeActivity(agentWorkerQueue, createCommentActivity, {
@@ -71,7 +89,7 @@ export async function agentChat(task: WorkflowTask): Promise<void> {
})
placeholderCommentId = placeholder.id
// 5. Prepare Images (Attachments only)
// Prepare Images (Attachments only)
if (userComment.attachments) {
for (const att of userComment.attachments) {
const attProxyType = (att.asset?.media as PrismaJson.MediaInfo | null)?.proxyType
@@ -118,43 +136,104 @@ export async function agentChat(task: WorkflowTask): Promise<void> {
projectId: payload.projectId,
})
const pathContext = await executeActivity(
const pathHierarchy = await executeActivity(
agentWorkerQueue,
getAssetPathContextActivity,
getAssetPathHierarchyActivity,
task.assetId,
)
const assetPath = pathHierarchy?.path || ''
const ancestors = pathHierarchy?.ancestors || []
// eslint-disable-next-line @typescript-eslint/no-explicit-any
const mediaInfo = asset.media as any
const duration = mediaInfo?.duration
const totalPages = mediaInfo?.frames || mediaInfo?.metadata?.totalFrames
const proxyType =
(asset.media as PrismaJson.MediaInfo | null)?.proxyType ||
getProxyType(asset.mediaType, asset.name) ||
undefined
const duration =
(proxyType === 'video' || proxyType === 'audio') && typeof mediaInfo?.duration === 'number'
? mediaInfo.duration
: undefined
const totalPages =
proxyType === 'pdf' ? mediaInfo?.frames || mediaInfo?.metadata?.totalFrames : undefined
const totalFrames =
proxyType === 'video' ? mediaInfo?.frames || mediaInfo?.metadata?.totalFrames : undefined
// Resolve Attached Files Details
const attachedFileDetailsList: string[] = []
const attachedFiles: ShumaiAttachedFileContext[] = []
const attachedAssets: Array<{ id: string; name: string; type: string }> = []
if (payload.agent?.attachedFiles) {
if (userCommentId && userComment?.attachments) {
for (const att of userComment.attachments) {
if (att.asset) {
const filePath = await executeActivity(
agentWorkerQueue,
getAssetPathContextActivity,
att.asset.id,
)
const attProxyType =
(att.asset.media as PrismaJson.MediaInfo | null)?.proxyType ||
getProxyType(att.asset.mediaType, att.asset.name) ||
undefined
attachedFiles.push({
id: att.asset.id,
name: att.asset.name,
type: att.asset.type,
mediaType: attProxyType as ShumaiAttachedFileContext['mediaType'],
mimeType: att.asset.mediaType || undefined,
path: filePath || undefined,
})
attachedAssets.push({ id: att.asset.id, name: att.asset.name, type: att.asset.type })
}
}
} else if (payload.agent?.attachedFiles) {
for (const fileId of payload.agent.attachedFiles) {
const file = await executeActivity(agentWorkerQueue, getAssetActivity, fileId)
if (file) {
const path = await executeActivity(agentWorkerQueue, getAssetPathContextActivity, fileId)
attachedFileDetailsList.push(
`- Name: ${file.name} (ID: ${file.id}, Type: ${file.type}, Media Type: ${file.mediaType || 'unknown'}, Project ID: ${file.projectId || 'unknown'}, Path: ${path})`,
const filePath = await executeActivity(
agentWorkerQueue,
getAssetPathContextActivity,
fileId,
)
const fileProxyType =
(file.media as PrismaJson.MediaInfo | null)?.proxyType ||
getProxyType(file.mediaType, file.name) ||
undefined
attachedFiles.push({
id: file.id,
name: file.name,
type: file.type,
mediaType: fileProxyType as ShumaiAttachedFileContext['mediaType'],
mimeType: file.mediaType || undefined,
path: filePath || undefined,
})
attachedAssets.push({ id: file.id, name: file.name, type: file.type })
}
}
}
// Resolve Referenced Workspace Assets Details
const referencedAssetDetailsList: string[] = []
const referencedAssets: ShumaiAttachedFileContext[] = []
if (payload.agent?.assetIds) {
for (const assetId of payload.agent.assetIds) {
const referencedAsset = await executeActivity(agentWorkerQueue, getAssetActivity, assetId)
if (referencedAsset) {
const path = await executeActivity(agentWorkerQueue, getAssetPathContextActivity, assetId)
referencedAssetDetailsList.push(
`- Name: ${referencedAsset.name} (ID: ${referencedAsset.id}, Type: ${referencedAsset.type}, Media Type: ${referencedAsset.mediaType || 'unknown'}, Project ID: ${referencedAsset.projectId || 'unknown'}, Path: ${path})`,
const filePath = await executeActivity(
agentWorkerQueue,
getAssetPathContextActivity,
assetId,
)
const refProxyType =
(referencedAsset.media as PrismaJson.MediaInfo | null)?.proxyType ||
getProxyType(referencedAsset.mediaType, referencedAsset.name) ||
undefined
referencedAssets.push({
id: referencedAsset.id,
name: referencedAsset.name,
type: referencedAsset.type,
mediaType: refProxyType as ShumaiAttachedFileContext['mediaType'],
mimeType: referencedAsset.mediaType || undefined,
path: filePath || undefined,
})
attachedAssets.push({
id: referencedAsset.id,
name: referencedAsset.name,
@@ -164,29 +243,53 @@ export async function agentChat(task: WorkflowTask): Promise<void> {
}
}
// Resolve User Info
const targetUserId = userCommentId ? commentCreatorId : payload.agent?.userId
let userInfo: { name: string; role: string } | null = null
if (!userCommentId && isNewChat && payload.agent?.userId) {
if (targetUserId) {
userInfo = await executeActivity(agentWorkerQueue, getUserTeamInfoActivity, {
userId: payload.agent.userId,
userId: targetUserId,
teamId,
})
}
const proxyType = (asset.media as PrismaJson.MediaInfo | null)?.proxyType
const promptBuilder = new AgentChatPromptBuilder(asset.id)
.withContinuation(!isNewChat)
.withAssetChanged(payload.agent?.hasAssetChanged)
.withPathContext(pathContext)
.withAssetDetails(asset.name, asset.mediaType, duration, totalPages, proxyType)
.withCommentTimestamp(commentTimestamp)
.withAttachedFiles(attachedFileDetailsList)
.withReferencedAssets(referencedAssetDetailsList)
if (userInfo) {
promptBuilder.withUserInfo(userInfo.name, userInfo.role)
// Build position
let mediaPosition: ShumaiMediaPosition | undefined
if (commentTimestamp !== undefined && commentTimestamp !== null) {
if (proxyType === 'pdf') {
mediaPosition = { type: 'page', page: Math.round(commentTimestamp) }
} else {
mediaPosition = { type: 'time', seconds: commentTimestamp }
}
}
const instruction = promptBuilder.build()
// Build Current Asset Context
const currentAssetContext: ShumaiAssetContext = {
id: asset.id,
name: asset.name,
type: asset.type,
mediaType: proxyType as ShumaiAssetContext['mediaType'],
mimeType: asset.mediaType || undefined,
parentId: asset.parentId || undefined,
path: assetPath || undefined,
durationSeconds: duration !== undefined ? duration : undefined,
totalFrames: totalFrames !== undefined ? totalFrames : undefined,
totalPages: totalPages !== undefined ? totalPages : undefined,
navigated: payload.agent?.hasAssetChanged === true ? true : undefined,
ancestors: ancestors.length > 0 ? ancestors : undefined,
}
// Build structured ShumaiMessageContext
const messageContext: ShumaiMessageContext = {
...(userInfo
? { user: { id: targetUserId!, name: userInfo.name, role: userInfo.role } }
: {}),
currentAsset: currentAssetContext,
...(mediaPosition ? { position: mediaPosition } : {}),
...(commentAnnotation ? { annotation: true } : {}),
...(attachedFiles.length > 0 ? { attachedFiles } : {}),
...(referencedAssets.length > 0 ? { referencedAssets } : {}),
}
// 6. Call AI Chat
let folderId = ''
@@ -205,11 +308,11 @@ export async function agentChat(task: WorkflowTask): Promise<void> {
projectId: payload.projectId,
folderId,
assetId: asset.id,
agentsInstruction: instruction,
sessionId,
userId: payload.agent?.userId,
userCommentId: userCommentId || undefined,
context,
messageContext,
attachedAssets,
})
@@ -1,140 +0,0 @@
import { describe, it, expect, vi, beforeEach } from 'vitest'
import { agentToolCall } from './agent-tool-call'
import { prisma } from '@shumai/db'
import { setupTestDbHooks } from '@shumai/db/test'
import * as workflowUtils from '@shumai/workflow-core'
vi.mock('@shumai/workflow-core', async () => {
const actual = await vi.importActual('@shumai/workflow-core')
return {
...actual,
getActivities: vi.fn(),
executeActivity: vi.fn(),
}
})
describe('Agent Tool Call Workflow', () => {
setupTestDbHooks()
// eslint-disable-next-line @typescript-eslint/no-explicit-any -- mockActivities holds mock functions cast to expected types
let mockActivities: any
beforeEach(() => {
vi.clearAllMocks()
mockActivities = {
updateTaskStatusActivity: Object.assign(vi.fn(), {
_activityName: 'updateTaskStatusActivity',
}),
executeAgentToolActivity: Object.assign(vi.fn(), {
_activityName: 'executeAgentToolActivity',
}),
getAgentWorkerQueueActivity: Object.assign(vi.fn(), {
_activityName: 'getAgentWorkerQueueActivity',
}),
}
mockActivities.getAgentWorkerQueueActivity.mockResolvedValue('agent_queue')
mockActivities.updateTaskStatusActivity.mockResolvedValue({})
mockActivities.executeAgentToolActivity.mockResolvedValue({ success: true, count: 42 })
// eslint-disable-next-line @typescript-eslint/no-explicit-any -- mockActivities contains vi.fn mock functions which are cast to expected activity proxy types
vi.mocked(workflowUtils.getActivities).mockReturnValue(mockActivities as any)
vi.mocked(workflowUtils.executeActivity).mockImplementation(async (_queue, act, ...args) => {
// eslint-disable-next-line @typescript-eslint/no-explicit-any -- act is one of the mocked activities
return (act as any)(...args)
})
})
it('should run agent tool call workflow successfully', async () => {
const task = await prisma.workflowTask.create({
data: {
type: 'agent_tool_call',
status: 'pending',
assetId: 'a1',
payload: {
projectId: 'p1',
agentToolCall: {
toolName: 'list_assets',
args: { parent: 'folder-123' },
userId: 'user-456',
},
},
},
})
await agentToolCall(task)
// Verify queue discovery
expect(mockActivities.getAgentWorkerQueueActivity).toHaveBeenCalled()
// Verify task processing status
expect(mockActivities.updateTaskStatusActivity).toHaveBeenCalledWith({
taskId: task.id,
status: 'processing',
})
// Verify tool execution
expect(mockActivities.executeAgentToolActivity).toHaveBeenCalledWith({
taskId: task.id,
toolName: 'list_assets',
args: { parent: 'folder-123' },
userId: 'user-456',
})
// Verify task completed status with output
expect(mockActivities.updateTaskStatusActivity).toHaveBeenCalledWith({
taskId: task.id,
status: 'completed',
output: { success: true, count: 42 },
})
})
it('should throw if payload or agentToolCall is missing', async () => {
const task = await prisma.workflowTask.create({
data: {
type: 'agent_tool_call',
status: 'pending',
assetId: 'a1',
},
})
await expect(agentToolCall(task)).rejects.toThrow('Task payload or agentToolCall is missing')
// Verify status updated to failed
expect(mockActivities.updateTaskStatusActivity).toHaveBeenCalledWith({
taskId: task.id,
status: 'failed',
output: { error: 'Task payload or agentToolCall is missing' },
})
})
it('should handle tool execution failures by updating task to failed and throwing', async () => {
mockActivities.executeAgentToolActivity.mockRejectedValue(new Error('Authz failure'))
const task = await prisma.workflowTask.create({
data: {
type: 'agent_tool_call',
status: 'pending',
assetId: 'a1',
payload: {
projectId: 'p1',
agentToolCall: {
toolName: 'create_folder',
args: { parent: 'folder-123', name: 'new-folder' },
userId: 'user-456',
},
},
},
})
await expect(agentToolCall(task)).rejects.toThrow('Authz failure')
// Verify task status failed
expect(mockActivities.updateTaskStatusActivity).toHaveBeenCalledWith({
taskId: task.id,
status: 'failed',
output: { error: 'Authz failure' },
})
})
})
@@ -1,60 +0,0 @@
import { ApplicationFailure } from '@temporalio/workflow'
import type { WorkflowTask } from '@shumai/db'
import { getActivities, executeActivity, TaskQueueAgent } from '@shumai/workflow-core'
export async function agentToolCall(task: WorkflowTask): Promise<void> {
const { updateTaskStatusActivity, executeAgentToolActivity, getAgentWorkerQueueActivity } =
getActivities()
let agentWorkerQueue = ''
try {
// 0. Discover queue
agentWorkerQueue = await executeActivity(TaskQueueAgent, getAgentWorkerQueueActivity)
// Update status to processing
await executeActivity(agentWorkerQueue, updateTaskStatusActivity, {
taskId: task.id,
status: 'processing',
})
const payload = task.payload
if (!payload || !payload.agentToolCall) {
throw ApplicationFailure.create({
message: 'Task payload or agentToolCall is missing',
nonRetryable: true,
})
}
const { toolName, args, userId } = payload.agentToolCall
// Execute the agent activity on specific queue
const result = await executeActivity(agentWorkerQueue, executeAgentToolActivity, {
taskId: task.id,
toolName,
args,
userId,
})
// Update status to completed with output
await executeActivity(agentWorkerQueue, updateTaskStatusActivity, {
taskId: task.id,
status: 'completed',
output: result,
})
} catch (err) {
console.error(`AgentToolCall failed for task ${task.id}:`, err)
// Update status to failed
if (agentWorkerQueue) {
await executeActivity(agentWorkerQueue, updateTaskStatusActivity, {
taskId: task.id,
status: 'failed',
output: { error: err instanceof Error ? err.message : String(err) },
})
}
throw err
}
}
export const agentToolCallWorkflow = agentToolCall
+1 -1
View File
@@ -1,6 +1,6 @@
{
"name": "@shumai/api",
"version": "0.4.0",
"version": "0.4.1",
"private": true,
"type": "module",
"main": "./src/index.ts",
+2 -2
View File
@@ -4,7 +4,7 @@ import { zValidator } from '@hono/zod-validator'
import { shareService } from '@shumai/core/src/share/share'
import { assetService } from '@shumai/core/src/asset/asset'
import { watermarkService } from '@shumai/core/src/watermark/watermark'
import { paginationParamsSchema } from '@shumai/dtos'
import { paginationParamsSchema, assetTypeFilterSchema } from '@shumai/dtos'
import { z } from 'zod'
import { metadataService } from '@shumai/core/src/metadata/metadata'
import { FieldInfo } from '@shumai/dtos'
@@ -117,7 +117,7 @@ export function handlePublicShareError(c: Context, err: unknown) {
}
const sharedChildrenRequestSchema = paginationParamsSchema.extend({
assetType: z.string().optional(),
assetType: assetTypeFilterSchema.optional().default('file'),
})
const route = app
+1 -1
View File
@@ -1,6 +1,6 @@
{
"name": "@shumai/core",
"version": "0.4.0",
"version": "0.4.1",
"private": true,
"type": "module",
"main": "./src/index.ts",
+462
View File
@@ -5,6 +5,8 @@ import { HTTPException } from 'hono/http-exception'
import { AssetType, AssetStatus, Prisma } from '@shumai/db'
import { s3Service } from '@shumai/core/src/s3/s3'
import { uploadService } from '@shumai/core/src/upload/upload'
import { metadataService } from '@shumai/core/src/metadata/metadata'
import { AssetService } from './asset'
vi.mock('@shumai/core/src/s3/s3', () => ({
@@ -568,6 +570,62 @@ describe('AssetService', () => {
})
})
it('rejects reparenting a version_stack onto a file', async () => {
const { user, assets } = await setupBasicAssets()
await expect(
assetService.reparentAssets({
assetIds: [assets.stackB.id],
newParentId: assets.fileA1.id,
creatorId: user.id,
}),
).rejects.toThrow('Source asset must be a file to create a version stack')
})
it('rejects reparenting a version_stack onto another version_stack', async () => {
const { user, assets, project } = await setupBasicAssets()
const stack2 = await prisma.asset.create({
data: {
name: 'stack2',
type: AssetType.version_stack,
projectId: project.id,
parentId: assets.folderA.id,
creatorId: user.id,
fileCount: 2,
sizeByte: 100,
status: 'uploaded',
},
})
await expect(
assetService.reparentAssets({
assetIds: [assets.stackB.id],
newParentId: stack2.id,
creatorId: user.id,
}),
).rejects.toThrow('Cannot move version_stack asset into a version stack')
})
it('rejects reparenting a folder onto a version_stack', async () => {
const { user, assets } = await setupBasicAssets()
await expect(
assetService.reparentAssets({
assetIds: [assets.folderA.id],
newParentId: assets.stackB.id,
creatorId: user.id,
}),
).rejects.toThrow('Cannot move folder asset into a version stack')
})
it('rejects reparenting multiple files onto a version_stack at once', async () => {
const { user, assets } = await setupBasicAssets()
await expect(
assetService.reparentAssets({
assetIds: [assets.fileA1.id, assets.fileA2.id],
newParentId: assets.stackB.id,
creatorId: user.id,
}),
).rejects.toThrow('Can only move one file at a time into a version stack')
})
describe('fileCount verification', () => {
it('createAsset should increment parent fileCount', async () => {
const { user, assets, project } = await setupBasicAssets()
@@ -3704,4 +3762,408 @@ describe('AssetService — natural sort by name', () => {
expect(purgedSymlink).toBeNull()
})
})
describe('createFile', () => {
it('creates a file, updates ancestor sizes, persists metadata, and triggers workflows', async () => {
const user = await prisma.user.create({
data: { name: 'FileUser', email: `fileuser-${Date.now()}@example.com` },
})
const team = await prisma.team.create({ data: { name: 'FileTeam' } })
const project = await prisma.project.create({
data: { name: 'FileProject', teamId: team.id },
})
const rootFolder = await prisma.asset.create({
data: {
name: 'RootFolder',
type: AssetType.folder,
projectId: project.id,
status: AssetStatus.uploaded,
},
})
const promptField = await metadataService.createProjectField(project.id, {
description: 'Prompt field',
config: {
name: 'Prompt',
type: 'text',
autofillSource: 'CREATION_CONTEXT',
},
})
const triggerSpy = vi
.spyOn(uploadService, 'triggerPostUploadWorkflows')
.mockResolvedValue(undefined)
const fileInfo = await assetService.createFile({
parentId: rootFolder.id,
name: 'document.txt',
key: 'files/test/doc.txt',
sizeByte: 1024,
contentType: 'text/plain',
creatorId: user.id,
metadata: { [promptField.key]: 'Project overview document' },
})
expect(fileInfo.id).toBeDefined()
expect(fileInfo.name).toBe('document.txt')
expect(fileInfo.type).toBe(AssetType.file)
expect(fileInfo.sizeByte).toBe(1024)
const folderAfter = await prisma.asset.findUnique({ where: { id: rootFolder.id } })
expect(folderAfter?.sizeByte).toBe(1024n)
expect(folderAfter?.fileCount).toBe(1)
const metaVal = await prisma.assetMetadataValue.findFirst({
where: { assetId: fileInfo.id, fieldKey: promptField.key },
})
expect(metaVal?.stringValue).toBe('Project overview document')
expect(triggerSpy).toHaveBeenCalledWith(expect.anything(), fileInfo.id, team.id, project.id)
})
it('rejects if metadata contains invalid keys', async () => {
const user = await prisma.user.create({
data: { name: 'FileUser2', email: `fileuser2-${Date.now()}@example.com` },
})
const team = await prisma.team.create({ data: { name: 'FileTeam2' } })
const project = await prisma.project.create({
data: { name: 'FileProject2', teamId: team.id },
})
const rootFolder = await prisma.asset.create({
data: {
name: 'RootFolder2',
type: AssetType.folder,
projectId: project.id,
status: AssetStatus.uploaded,
},
})
await expect(
assetService.createFile({
parentId: rootFolder.id,
name: 'invalid.txt',
key: 'files/test/inv.txt',
sizeByte: 100,
contentType: 'text/plain',
creatorId: user.id,
metadata: { unknownField: 'val' },
}),
).rejects.toThrow(/metadata contains keys that are not valid in this project/)
})
it('rolls back completely if post-upload workflow fails in transaction', async () => {
const user = await prisma.user.create({
data: { name: 'FileRollbackUser', email: `filerollback-${Date.now()}@example.com` },
})
const team = await prisma.team.create({ data: { name: 'FileRollbackTeam' } })
const project = await prisma.project.create({
data: { name: 'FileRollbackProject', teamId: team.id },
})
const rootFolder = await prisma.asset.create({
data: {
name: 'RootFolder',
type: AssetType.folder,
projectId: project.id,
status: AssetStatus.uploaded,
sizeByte: 0n,
fileCount: 0,
},
})
vi.spyOn(uploadService, 'triggerPostUploadWorkflows').mockRejectedValueOnce(
new Error('Simulated workflow failure'),
)
await expect(
assetService.createFile({
parentId: rootFolder.id,
name: 'should_rollback.txt',
key: 'files/test/should_rollback.txt',
sizeByte: 1024,
contentType: 'text/plain',
creatorId: user.id,
}),
).rejects.toThrow('Simulated workflow failure')
// Assert no asset was created
const created = await prisma.asset.findFirst({
where: { name: 'should_rollback.txt', projectId: project.id },
})
expect(created).toBeNull()
// Assert parent folder counters remained untouched
const folderAfter = await prisma.asset.findUnique({ where: { id: rootFolder.id } })
expect(folderAfter?.fileCount).toBe(0)
expect(folderAfter?.sizeByte).toBe(0n)
})
})
describe('createVersion', () => {
it('creates a version stack when target is a regular file', async () => {
const user = await prisma.user.create({
data: { name: 'VersionUser', email: `veruser-${Date.now()}@example.com` },
})
const team = await prisma.team.create({ data: { name: 'VersionTeam' } })
const project = await prisma.project.create({
data: { name: 'VersionProject', teamId: team.id },
})
const rootFolder = await prisma.asset.create({
data: {
name: 'RootFolder',
type: AssetType.folder,
projectId: project.id,
status: AssetStatus.uploaded,
},
})
const v1 = await prisma.asset.create({
data: {
name: 'image.png',
type: AssetType.file,
projectId: project.id,
parentId: rootFolder.id,
status: AssetStatus.uploaded,
sizeByte: 2000n,
},
})
const triggerSpy = vi
.spyOn(uploadService, 'triggerPostUploadWorkflows')
.mockResolvedValue(undefined)
const v2Info = await assetService.createVersion({
parentId: v1.id,
name: 'image.png',
key: 'files/test/v2.png',
sizeByte: 3000,
contentType: 'image/png',
creatorId: user.id,
})
expect(v2Info.id).toBeDefined()
const v2Record = await prisma.asset.findUnique({
where: { id: v2Info.id },
include: { parent: true },
})
expect(v2Record?.parent?.type).toBe(AssetType.version_stack)
expect(v2Record?.parent?.parentId).toBe(rootFolder.id)
const v1Record = await prisma.asset.findUnique({ where: { id: v1.id } })
expect(v1Record?.parentId).toBe(v2Record?.parentId)
const stackRecord = await prisma.asset.findUnique({ where: { id: v2Record!.parentId! } })
expect(stackRecord?.fileCount).toBe(2)
expect(stackRecord?.sizeByte).toBe(5000n)
expect(triggerSpy).toHaveBeenCalledWith(expect.anything(), v2Info.id, team.id, project.id)
})
it('appends a new version when target is in an existing version stack', async () => {
const user = await prisma.user.create({
data: { name: 'VersionUser2', email: `veruser2-${Date.now()}@example.com` },
})
const team = await prisma.team.create({ data: { name: 'VersionTeam2' } })
const project = await prisma.project.create({
data: { name: 'VersionProject2', teamId: team.id },
})
const rootFolder = await prisma.asset.create({
data: {
name: 'RootFolder',
type: AssetType.folder,
projectId: project.id,
status: AssetStatus.uploaded,
},
})
const stack = await prisma.asset.create({
data: {
name: 'image.png',
type: AssetType.version_stack,
projectId: project.id,
parentId: rootFolder.id,
status: AssetStatus.uploaded,
sizeByte: 2000n,
fileCount: 1,
},
})
const v1 = await prisma.asset.create({
data: {
name: 'image.png',
type: AssetType.file,
projectId: project.id,
parentId: stack.id,
status: AssetStatus.uploaded,
sortIndex: 'a0',
sizeByte: 2000n,
},
})
const triggerSpy = vi
.spyOn(uploadService, 'triggerPostUploadWorkflows')
.mockResolvedValue(undefined)
const v2Info = await assetService.createVersion({
parentId: v1.id,
name: 'image_v2.png',
key: 'files/test/v2.png',
sizeByte: 3000,
contentType: 'image/png',
creatorId: user.id,
})
expect(v2Info.id).toBeDefined()
const v2Record = await prisma.asset.findUnique({ where: { id: v2Info.id } })
expect(v2Record?.parentId).toBe(stack.id)
const stackAfter = await prisma.asset.findUnique({ where: { id: stack.id } })
expect(stackAfter?.fileCount).toBe(2)
expect(stackAfter?.sizeByte).toBe(5000n)
expect(triggerSpy).toHaveBeenCalledWith(expect.anything(), v2Info.id, team.id, project.id)
})
it('rolls back completely if workflow triggering fails in createVersion', async () => {
const user = await prisma.user.create({
data: { name: 'VersionRollbackUser', email: `verrollback-${Date.now()}@example.com` },
})
const team = await prisma.team.create({ data: { name: 'VersionRollbackTeam' } })
const project = await prisma.project.create({
data: { name: 'VersionRollbackProject', teamId: team.id },
})
const rootFolder = await prisma.asset.create({
data: {
name: 'RootFolder',
type: AssetType.folder,
projectId: project.id,
status: AssetStatus.uploaded,
sizeByte: 2000n,
fileCount: 1,
},
})
const v1 = await prisma.asset.create({
data: {
name: 'image.png',
type: AssetType.file,
projectId: project.id,
parentId: rootFolder.id,
status: AssetStatus.uploaded,
sizeByte: 2000n,
},
})
vi.spyOn(uploadService, 'triggerPostUploadWorkflows').mockRejectedValueOnce(
new Error('Simulated version workflow failure'),
)
await expect(
assetService.createVersion({
parentId: v1.id,
name: 'image_v2_fail.png',
key: 'files/test/v2_fail.png',
sizeByte: 3000,
contentType: 'image/png',
creatorId: user.id,
}),
).rejects.toThrow('Simulated version workflow failure')
// Check that new version was rolled back
const createdV2 = await prisma.asset.findFirst({
where: { name: 'image_v2_fail.png', projectId: project.id },
})
expect(createdV2).toBeNull()
// Check that v1 remains under rootFolder (no orphaned version stack created)
const v1After = await prisma.asset.findUnique({ where: { id: v1.id } })
expect(v1After?.parentId).toBe(rootFolder.id)
// Check root folder counters remained unchanged
const rootFolderAfter = await prisma.asset.findUnique({ where: { id: rootFolder.id } })
expect(rootFolderAfter?.fileCount).toBe(1)
expect(rootFolderAfter?.sizeByte).toBe(2000n)
})
})
describe('listChildren type filtering', () => {
it('returns files, folders, and version stacks when assetType is all or omitted', async () => {
const team = await prisma.team.create({ data: { name: 'ListTypeTeam' } })
const project = await prisma.project.create({
data: { name: 'ListTypeProject', teamId: team.id },
})
const rootFolder = await prisma.asset.create({
data: {
name: 'RootFolder',
type: AssetType.folder,
projectId: project.id,
status: AssetStatus.uploaded,
},
})
const subFolder = await prisma.asset.create({
data: {
name: 'subfolder',
type: AssetType.folder,
projectId: project.id,
parentId: rootFolder.id,
status: AssetStatus.uploaded,
},
})
const file = await prisma.asset.create({
data: {
name: 'file.txt',
type: AssetType.file,
projectId: project.id,
parentId: rootFolder.id,
status: AssetStatus.uploaded,
},
})
const stack = await prisma.asset.create({
data: {
name: 'stack.png',
type: AssetType.version_stack,
projectId: project.id,
parentId: rootFolder.id,
status: AssetStatus.uploaded,
},
})
// Query with assetType: 'all'
const allRes = await assetService.listChildren({
assetId: rootFolder.id,
assetType: 'all',
})
const allIds = allRes.data.map((a) => a.id)
expect(allIds).toContain(subFolder.id)
expect(allIds).toContain(file.id)
expect(allIds).toContain(stack.id)
expect(allRes.data.length).toBe(3)
// Query with assetType: 'file'
const fileRes = await assetService.listChildren({
assetId: rootFolder.id,
assetType: 'file',
})
const fileIds = fileRes.data.map((a) => a.id)
expect(fileIds).toContain(file.id)
expect(fileIds).toContain(stack.id)
expect(fileIds).not.toContain(subFolder.id)
expect(fileRes.data.length).toBe(2)
// Query with assetType: 'folder'
const folderRes = await assetService.listChildren({
assetId: rootFolder.id,
assetType: 'folder',
})
const folderIds = folderRes.data.map((a) => a.id)
expect(folderIds).toContain(subFolder.id)
expect(folderIds).not.toContain(file.id)
expect(folderIds).not.toContain(stack.id)
expect(folderRes.data.length).toBe(1)
})
})
})
+194 -8
View File
@@ -29,6 +29,8 @@ import { generateKeyBetween } from 'jittered-fractional-indexing'
import { getAvatarUrl } from '@shumai/core/src/user/avatar'
import { getAgentRequiredLevel, getRoleLevel } from '@shumai/core/src/agent/permissions'
import { resolveEffectiveRole } from '@shumai/core/src/authz/authz'
import { metadataService } from '@shumai/core/src/metadata/metadata'
import { uploadService } from '@shumai/core/src/upload/upload'
export const assetInclude = {
creator: true,
@@ -209,6 +211,12 @@ export class AssetService {
return this.reparentFileToFile(tx, newParent, req.assetIds, req.creatorId)
}
if (newParent.type === AssetType.version_stack) {
if (req.assetIds.length !== 1) {
throw new Error('Can only move one file at a time into a version stack')
}
}
const assetsToMove = await tx.asset.findMany({
where: { id: { in: req.assetIds } },
include: { project: { include: { team: true } } },
@@ -220,6 +228,14 @@ export class AssetService {
if (assetsToMove.length === 0) return
if (newParent.type === AssetType.version_stack) {
for (const a of assetsToMove) {
if (a.type !== AssetType.file) {
throw new Error(`Cannot move ${a.type} asset into a version stack`)
}
}
}
let totalSize = 0
const oldParentId = assetsToMove[0].parentId
if (!oldParentId) {
@@ -522,6 +538,10 @@ export class AssetService {
assetIds: string[],
creatorId?: string,
) {
if (destFile.type !== AssetType.file) {
throw new Error('Destination asset must be a file')
}
if (assetIds.length !== 1) {
throw new Error('Can only reparent one file to another file')
}
@@ -537,6 +557,10 @@ export class AssetService {
if (!sourceAsset) throw new Error('Source asset not found')
if (sourceAsset.type !== AssetType.file) {
throw new Error('Source asset must be a file to create a version stack')
}
if (!sourceAsset.project || !sourceAsset.project.team) {
throw new Error(`Asset ${sourceAsset.id} is not associated with a team`)
}
@@ -614,9 +638,13 @@ export class AssetService {
}
async listChildren(req: ListChildrenRequest): Promise<PaginatedData<AssetInfo[]>> {
const typesToQuery: AssetType[] = [req.assetType as AssetType]
if (req.assetType === AssetType.file) {
typesToQuery.push(AssetType.version_stack)
let typesToQuery: AssetType[]
if (req.assetType === 'file') {
typesToQuery = [AssetType.file, AssetType.version_stack]
} else if (req.assetType === 'folder') {
typesToQuery = [AssetType.folder]
} else {
typesToQuery = [AssetType.file, AssetType.folder, AssetType.version_stack]
}
let where: Prisma.AssetWhereInput = {}
@@ -721,12 +749,17 @@ export class AssetService {
return { data: infos, pageInfo }
}
async createAsset(req: CreateAssetRequest): Promise<AssetInfo> {
async createAsset(
req: CreateAssetRequest,
txClient?: Prisma.TransactionClient,
): Promise<AssetInfo> {
const db = txClient ?? this.prismaClient
let projectId = req.projectId
let parent: Prisma.AssetGetPayload<{ include: { project: true } }> | null = null
if (req.parentId) {
parent = await this.prismaClient.asset.findUnique({
parent = await db.asset.findUnique({
where: { id: req.parentId },
include: { project: true },
})
@@ -738,7 +771,7 @@ export class AssetService {
let sortIndex: string | null = null
if (parent) {
const firstFile = await this.prismaClient.asset.findFirst({
const firstFile = await db.asset.findFirst({
where: { parentId: parent.id },
orderBy: { sortIndex: 'asc' },
})
@@ -766,7 +799,7 @@ export class AssetService {
if (req.contentType) data.mediaType = req.contentType
if (req.creatorId) data.creator = { connect: { id: req.creatorId } }
const asset = await this.prismaClient.$transaction(async (tx) => {
const executeInTx = async (tx: Prisma.TransactionClient) => {
const createdAsset = await tx.asset.create({
data,
include: {
@@ -803,12 +836,165 @@ export class AssetService {
}
return createdAsset
})
}
const asset = txClient
? await executeInTx(txClient)
: await this.prismaClient.$transaction(executeInTx)
const infos = await this.toAssetInfos([asset])
return infos[0]
}
async createFile(params: {
parentId: string
name: string
key: string
sizeByte: number
contentType: string
creatorId: string
metadata?: Record<string, unknown>
}): Promise<AssetInfo> {
const { parentId, name, key, sizeByte, contentType, creatorId, metadata } = params
const parentAsset = await this.prismaClient.asset.findUnique({
where: { id: parentId },
include: { project: true },
})
if (!parentAsset || !parentAsset.projectId || !parentAsset.project?.teamId) {
throw new Error(`Parent folder ${parentId} is invalid or has no project associated`)
}
if (metadata) {
await metadataService.validateCreationContextMetadata(
creatorId,
parentAsset.projectId,
metadata,
)
}
let newFileId = ''
await this.prismaClient.$transaction(async (tx) => {
const newFile = await this.createAsset(
{
name,
type: 'file',
parentId,
key,
sizeByte,
contentType,
creatorId,
},
tx,
)
newFileId = newFile.id
await this.updateAncestorsSize(tx, parentId, sizeByte)
if (metadata) {
const metadataUpdates = Object.entries(metadata)
.filter(([, value]) => value !== null)
.map(([k, v]) => ({ key: k, value: v }))
if (metadataUpdates.length > 0) {
await metadataService.updateAssetMetadataInTx(tx, newFile.id, metadataUpdates)
}
}
await uploadService.triggerPostUploadWorkflows(
tx,
newFile.id,
parentAsset.project!.teamId,
parentAsset.projectId!,
)
})
return this.getAsset({ assetId: newFileId })
}
async createVersion(params: {
parentId: string
name: string
key: string
sizeByte: number
contentType: string
creatorId: string
metadata?: Record<string, unknown>
}): Promise<AssetInfo> {
const { parentId, name, key, sizeByte, contentType, creatorId, metadata } = params
const targetAsset = await this.prismaClient.asset.findUnique({
where: { id: parentId },
include: { project: true, parent: true },
})
if (!targetAsset || !targetAsset.projectId || !targetAsset.project?.teamId) {
throw new Error(`Target file ${parentId} is invalid or has no project associated`)
}
if (metadata) {
await metadataService.validateCreationContextMetadata(
creatorId,
targetAsset.projectId,
metadata,
)
}
let targetFolderId: string
let reparentTargetId: string
if (targetAsset.type === AssetType.version_stack) {
targetFolderId = targetAsset.parentId!
reparentTargetId = targetAsset.id
} else if (targetAsset.parent?.type === AssetType.version_stack) {
targetFolderId = targetAsset.parent.parentId!
reparentTargetId = targetAsset.parentId!
} else {
targetFolderId = targetAsset.parentId!
reparentTargetId = targetAsset.id
}
let newFileId = ''
await this.prismaClient.$transaction(async (tx) => {
const newFile = await this.createAsset(
{
name,
type: 'file',
parentId: targetFolderId,
key,
sizeByte,
contentType,
creatorId,
},
tx,
)
newFileId = newFile.id
await this.reparentAssets(
{
assetIds: [newFile.id],
newParentId: reparentTargetId,
creatorId,
},
tx,
)
if (metadata) {
const metadataUpdates = Object.entries(metadata)
.filter(([, value]) => value !== null)
.map(([k, v]) => ({ key: k, value: v }))
if (metadataUpdates.length > 0) {
await metadataService.updateAssetMetadataInTx(tx, newFile.id, metadataUpdates)
}
}
await uploadService.triggerPostUploadWorkflows(
tx,
newFile.id,
targetAsset.project!.teamId,
targetAsset.projectId!,
)
})
return this.getAsset({ assetId: newFileId })
}
async findAsset(parentId: string, name: string): Promise<AssetInfo | null> {
const asset = await this.prismaClient.asset.findFirst({
where: { parentId, name },
+88
View File
@@ -613,6 +613,53 @@ describe('ChatService', () => {
expect(mapEntryToMessage(leafRecord)).toBeNull()
})
it('should map shumai_message custom_message entries with clean text and structured details', () => {
const entryRecord = {
id: 'entry-shumai-msg',
type: 'custom_message',
parentId: null,
createdAt: new Date('2026-07-07T00:05:00.000Z'),
data: {
customType: 'shumai_message',
content: 'Please adjust color grading',
display: true,
details: {
user: { id: 'u1', name: 'Alice', role: 'editor' },
currentAsset: { id: 'a1', name: 'video.mp4', type: 'file' },
position: { type: 'time', seconds: 12.5 },
},
},
} as unknown as Parameters<typeof mapEntryToMessage>[0]
const msg = mapEntryToMessage(entryRecord)
expect(msg).toBeDefined()
expect(msg?.id).toBe('entry-shumai-msg')
expect(msg?.role).toBe('custom')
// eslint-disable-next-line @typescript-eslint/no-explicit-any
expect((msg as any)?.customType).toBe('shumai_message')
// eslint-disable-next-line @typescript-eslint/no-explicit-any
expect((msg as any)?.content).toBe('Please adjust color grading')
// eslint-disable-next-line @typescript-eslint/no-explicit-any
expect((msg as any)?.details?.user?.name).toBe('Alice')
// eslint-disable-next-line @typescript-eslint/no-explicit-any
expect((msg as any)?.details?.position?.seconds).toBe(12.5)
})
it('should skip legacy context custom_message in mapEntryToMessage', () => {
const entryRecord = {
id: 'entry-legacy-context',
type: 'custom_message',
parentId: null,
createdAt: new Date('2026-07-07T00:05:00.000Z'),
data: {
customType: 'context',
content: 'System context prompt...',
},
} as unknown as Parameters<typeof mapEntryToMessage>[0]
expect(mapEntryToMessage(entryRecord)).toBeNull()
})
describe('getNewSessionMessages', () => {
it('returns new messages and lastEntryId', async () => {
const { user, team, project } = await setupBasicData()
@@ -900,5 +947,46 @@ describe('ChatService', () => {
}),
).rejects.toThrow(/Insufficient role/)
})
it('safely maps entries without message object or with customType shumai_message', () => {
// 1. Entry with type: 'message' but customType: 'shumai_message'
const legacyEntry = {
id: 'legacy-1',
sessionId: 'sess-1',
assetId: null,
parentId: null,
type: 'message',
data: {
customType: 'shumai_message',
content: 'Hello legacy',
display: true,
details: { user: { id: 'u1', name: 'User 1' } },
},
createdAt: new Date(),
}
const msg1 = mapEntryToMessage(legacyEntry)
expect(msg1).toBeDefined()
expect(msg1?.role).toBe('custom')
if (msg1 && msg1.role === 'custom') {
expect(msg1.customType).toBe('shumai_message')
expect(msg1.content).toBe('Hello legacy')
expect(msg1.details).toEqual({ user: { id: 'u1', name: 'User 1' } })
}
// 2. Entry with type: 'message' but empty data / no message
const emptyEntry = {
id: 'empty-1',
sessionId: 'sess-1',
assetId: null,
parentId: null,
type: 'message',
data: {},
createdAt: new Date(),
}
const msg2 = mapEntryToMessage(emptyEntry)
expect(msg2).toBeNull()
})
})
})
+30 -6
View File
@@ -30,11 +30,31 @@ export function buildSessionMessages(pathEntries: PathEntry[]): ChatMessage[] {
const appendMessage = (entry: PathEntry) => {
const timestampMs = new Date(entry.timestamp).getTime()
if (entry.type === 'message') {
messages.push({
...entry.message,
id: entry.id,
timestamp: entry.message.timestamp || timestampMs,
} as unknown as ChatMessage)
if ((entry as unknown as { customType?: string }).customType === 'shumai_message') {
const customEntry = entry as unknown as {
customType: string
content: string
display?: boolean
details?: Record<string, unknown>
}
messages.push({
id: entry.id,
role: 'custom',
customType: customEntry.customType,
content: customEntry.content,
display: customEntry.display,
details: customEntry.details,
timestamp: timestampMs,
} as unknown as ChatMessage)
return
}
if (entry.message) {
messages.push({
...entry.message,
id: entry.id,
timestamp: entry.message.timestamp || timestampMs,
} as unknown as ChatMessage)
}
} else if (entry.type === 'custom_message') {
if (entry.customType === 'context') return
messages.push({
@@ -117,9 +137,13 @@ export function mapEntryToMessage(
entryRecord: Prisma.AgentSessionEntryGetPayload<Record<string, never>>,
): ChatMessage | null {
const payload = (entryRecord.data as Record<string, unknown>) || {}
let type = (entryRecord.type || 'message') as SessionTreeEntry['type']
if (type === 'message' && payload.customType === 'shumai_message') {
type = 'custom_message'
}
const entryObj = {
id: entryRecord.id,
type: (entryRecord.type || 'message') as SessionTreeEntry['type'],
type,
parentId: entryRecord.parentId,
timestamp: entryRecord.createdAt.toISOString(),
...payload,
@@ -549,4 +549,65 @@ describe('MetadataService', () => {
]),
).rejects.toThrow('expected string or {newOption}')
})
describe('validateCreationContextMetadata', () => {
it('passes for allowed CREATION_CONTEXT fields and throws for invalid fields', async () => {
const team = await prisma.team.create({ data: { name: 'test-team-meta' } })
const project = await prisma.project.create({
data: { name: 'test-project-meta', teamId: team.id },
})
const validField = await prisma.metadataField.create({
data: {
key: 'prompt_field',
scope: 'PROJECT',
project: { connect: { id: project.id } },
config: {
name: 'Prompt',
type: 'text',
autofillSource: 'CREATION_CONTEXT',
},
},
})
await prisma.metadataField.create({
data: {
key: 'other_field',
scope: 'PROJECT',
project: { connect: { id: project.id } },
config: {
name: 'Other',
type: 'text',
autofillSource: 'NONE',
},
},
})
// Valid: empty metadata or null/undefined
await expect(
metadataService.validateCreationContextMetadata(null, project.id, null),
).resolves.toBeUndefined()
await expect(
metadataService.validateCreationContextMetadata(null, project.id, {}),
).resolves.toBeUndefined()
// Valid: allowed key
await expect(
metadataService.validateCreationContextMetadata(null, project.id, {
[validField.key]: 'valid value',
}),
).resolves.toBeUndefined()
// Invalid: non-CREATION_CONTEXT key or non-existent key
await expect(
metadataService.validateCreationContextMetadata(null, project.id, {
otherField: 'value',
}),
).rejects.toThrow(/metadata contains keys that are not valid in this project/)
await expect(
metadataService.validateCreationContextMetadata(null, project.id, {
randomFakeKey: 'value',
}),
).rejects.toThrow(/metadata contains keys that are not valid in this project/)
})
})
})
+23
View File
@@ -215,6 +215,29 @@ export class MetadataService {
return res
}
async validateCreationContextMetadata(
userId: string | null,
projectId: string,
metadata?: Record<string, unknown> | null,
): Promise<void> {
if (!metadata || Object.keys(metadata).length === 0) return
const fields = await this.listProjectFields(userId, projectId)
const allowedKeys = new Set(
fields
.filter((f) => f.field.config?.autofillSource === 'CREATION_CONTEXT')
.map((f) => f.field.key),
)
const invalidKeys = Object.keys(metadata).filter((key) => !allowedKeys.has(key))
if (invalidKeys.length > 0) {
throw new Error(
`metadata contains keys that are not valid in this project: ${invalidKeys.join(', ')}. ` +
"The valid metadata fields are fixed to the current conversation's project. " +
'If the target folder or file belongs to a different project, call the tool WITHOUT the metadata parameter.',
)
}
}
private async getProjectFieldsOrder(
userId: string,
projectId: string,
+1 -1
View File
@@ -1,6 +1,6 @@
{
"name": "@shumai/db",
"version": "0.4.0",
"version": "0.4.1",
"private": true,
"type": "module",
"main": "./src/index.ts",
+1 -1
View File
@@ -117,7 +117,7 @@ enum WorkflowTaskType {
chat
ai_embedding
query_embedding_for_search
agent_tool_call
agent_tool_call // @deprecated: Agent tools now execute directly in-process via Core services
kanban_agent_run
}
+3 -7
View File
@@ -8,6 +8,8 @@ declare global {
'id' | 'type' | 'parentId' | 'timestamp'
>
export type ShumaiMessageContext = import('@shumai/dtos').ShumaiMessageContext
// ----------------------------------------------------------------------
// User Agent Settings
// ----------------------------------------------------------------------
@@ -275,7 +277,6 @@ declare global {
queryEmbeddingForSearch?: {
text: string
}
agentToolCall?: AgentToolCallPayload
screenshot?: ScreenshotSpec
imageAnnotation?: ImageAnnotationSpec
pdfPages?: PdfPagesSpec
@@ -285,12 +286,6 @@ declare global {
// ----------------------------------------------------------------------
// Task Spec & Payload
// ----------------------------------------------------------------------
export interface AgentToolCallPayload {
toolName: string
args: Record<string, unknown>
userId: string
}
export interface TaskSpec {
videoStrategy?: VideoTranscodeStrategy
hardwareAcceleration?: HardwareAcceleration
@@ -310,6 +305,7 @@ declare global {
assetIds?: string[]
isNewChat?: boolean
hasAssetChanged?: boolean
context?: import('@shumai/dtos').ShumaiMessageContext
}
// ----------------------------------------------------------------------
+1 -1
View File
@@ -1,6 +1,6 @@
{
"name": "@shumai/dtos",
"version": "0.4.0",
"version": "0.4.1",
"private": true,
"type": "module",
"main": "./src/index.ts",
+4 -1
View File
@@ -160,9 +160,12 @@ export const updateAssetNameRequestSchema = z.object({
})
export type UpdateAssetNameRequest = z.infer<typeof updateAssetNameRequestSchema>
export const assetTypeFilterSchema = z.enum(['file', 'folder', 'all'])
export type AssetTypeFilter = z.infer<typeof assetTypeFilterSchema>
export const listChildrenRequestSchema = z.object({
assetId: z.string().optional(),
assetType: z.string(),
assetType: assetTypeFilterSchema.optional().default('all'),
projectId: z.string().optional(),
showDeleted: z.boolean().optional(),
prefix: z.string().optional(),
+69 -2
View File
@@ -39,11 +39,78 @@ export const chatSessionInfoSchema = z.object({
export type ChatSessionInfo = z.infer<typeof chatSessionInfoSchema>
export const shumaiAssetContextSchema = z.object({
id: z.string(),
name: z.string(),
type: z.string(),
mediaType: z.enum(['image', 'video', 'pdf', 'audio', 'other']).optional(),
mimeType: z.string().optional(),
parentId: z.string().optional(),
path: z.string().optional(),
durationSeconds: z.number().optional(),
totalFrames: z.number().optional(),
totalPages: z.number().optional(),
navigated: z.boolean().optional(),
ancestors: z.array(z.object({ id: z.string(), name: z.string() })).optional(),
})
export type ShumaiAssetContext = z.infer<typeof shumaiAssetContextSchema>
export const shumaiAttachedFileContextSchema = z.object({
id: z.string(),
name: z.string(),
type: z.string(),
mediaType: z.enum(['image', 'video', 'pdf', 'audio', 'other']).optional(),
mimeType: z.string().optional(),
path: z.string().optional(),
})
export type ShumaiAttachedFileContext = z.infer<typeof shumaiAttachedFileContextSchema>
export const shumaiMediaPositionSchema = z.discriminatedUnion('type', [
z.object({ type: z.literal('time'), seconds: z.number() }),
z.object({ type: z.literal('page'), page: z.number() }),
])
export type ShumaiMediaPosition = z.infer<typeof shumaiMediaPositionSchema>
export const shumaiMessageContextSchema = z.object({
user: z
.object({
id: z.string(),
name: z.string(),
role: z.string(),
})
.optional(),
currentAsset: shumaiAssetContextSchema.optional(),
position: shumaiMediaPositionSchema.optional(),
annotation: z.boolean().optional(),
attachedFiles: z.array(shumaiAttachedFileContextSchema).optional(),
referencedAssets: z.array(shumaiAttachedFileContextSchema).optional(),
})
export type ShumaiMessageContext = z.infer<typeof shumaiMessageContextSchema>
export const chatMessageSchema = z.intersection(
z.object({
id: z.string(),
}),
z.unknown(),
) as unknown as z.ZodType<AgentMessage & { id: string }>
) as unknown as z.ZodType<ChatMessage>
export type ChatMessage = AgentMessage & { id: string }
export type ChatMessage = (
| AgentMessage
| {
role: 'custom'
customType: string
content?: unknown
display?: boolean
details?: unknown
timestamp?: number
}
| {
role: 'thinking_level_change'
content: string
timestamp?: number
}
) & { id: string }
+148
View File
@@ -0,0 +1,148 @@
import type { ShumaiMessageContext } from './chat'
/**
* Escapes special XML characters in attribute and text values to prevent
* XML malformation and prompt injection.
*/
export function escapeXmlAttr(str: string): string {
return str
.replace(/&/g, '&amp;')
.replace(/</g, '&lt;')
.replace(/>/g, '&gt;')
.replace(/"/g, '&quot;')
.replace(/'/g, '&apos;')
}
function formatAttr(name: string, value: string | undefined): string {
if (value === undefined || value === null) return ''
return ` ${name}="${escapeXmlAttr(value)}"`
}
/**
* Pure, deterministic serializer that converts a ShumaiMessageContext
* object into a standardized, order-stable <context> XML block.
*
* Adheres strictly to the following invariants:
* 1. Tag sequence: <user>, <current_asset>, <position>, <annotation>, <attached_files>, <referenced_assets>
* 2. Attribute sequence on every tag follows fixed, invariant order.
* 3. Arrays (attachedFiles, referencedAssets) sorted by id ascending.
* 4. Floats formatted with .toFixed(2), integers rounded.
* 5. String values escaped via escapeXmlAttr.
* 6. Exact 2-space indentation and LF newlines.
*/
export function serializeContextToXml(context?: ShumaiMessageContext | null): string {
if (!context) return ''
const lines: string[] = []
// 1. <user ... />
if (context.user) {
let userAttrs = ''
if (context.user.id !== undefined) userAttrs += formatAttr('id', context.user.id)
if (context.user.name !== undefined) userAttrs += formatAttr('name', context.user.name)
if (context.user.role !== undefined) userAttrs += formatAttr('role', context.user.role)
if (userAttrs) {
lines.push(` <user${userAttrs} />`)
}
}
// 2. <current_asset ...> ... </current_asset>
if (context.currentAsset) {
const ca = context.currentAsset
let assetAttrs = ''
if (ca.id !== undefined) assetAttrs += formatAttr('id', ca.id)
if (ca.name !== undefined) assetAttrs += formatAttr('name', ca.name)
if (ca.type !== undefined) assetAttrs += formatAttr('type', ca.type)
if (ca.mediaType !== undefined) assetAttrs += formatAttr('media_type', ca.mediaType)
if (ca.mimeType !== undefined) assetAttrs += formatAttr('mime_type', ca.mimeType)
if (ca.parentId !== undefined) assetAttrs += formatAttr('parent_id', ca.parentId)
if (ca.path !== undefined) assetAttrs += formatAttr('path', ca.path)
if (ca.durationSeconds !== undefined) {
assetAttrs += ` duration_seconds="${ca.durationSeconds.toFixed(2)}"`
}
if (ca.totalFrames !== undefined) {
assetAttrs += ` total_frames="${Math.round(ca.totalFrames)}"`
}
if (ca.totalPages !== undefined) {
assetAttrs += ` total_pages="${Math.round(ca.totalPages)}"`
}
if (ca.navigated !== undefined) {
assetAttrs += ` navigated="${String(ca.navigated)}"`
}
if (ca.ancestors && ca.ancestors.length > 0) {
lines.push(` <current_asset${assetAttrs}>`)
lines.push(' <ancestors>')
for (const anc of ca.ancestors) {
let ancAttrs = ''
if (anc.id !== undefined) ancAttrs += formatAttr('id', anc.id)
if (anc.name !== undefined) ancAttrs += formatAttr('name', anc.name)
lines.push(` <folder${ancAttrs} />`)
}
lines.push(' </ancestors>')
lines.push(' </current_asset>')
} else {
lines.push(` <current_asset${assetAttrs} />`)
}
}
// 3. <position ... />
if (context.position) {
if (context.position.type === 'time') {
lines.push(` <position type="time" seconds="${context.position.seconds.toFixed(2)}" />`)
} else if (context.position.type === 'page') {
lines.push(` <position type="page" page="${Math.round(context.position.page)}" />`)
}
}
// 4. <annotation />
if (context.annotation) {
lines.push(' <annotation />')
}
// 5. <attached_files> ... </attached_files>
if (context.attachedFiles && context.attachedFiles.length > 0) {
const sortedFiles = [...context.attachedFiles].sort((a, b) => a.id.localeCompare(b.id))
lines.push(' <attached_files>')
for (const file of sortedFiles) {
let fileAttrs = ''
if (file.id !== undefined) fileAttrs += formatAttr('id', file.id)
if (file.name !== undefined) fileAttrs += formatAttr('name', file.name)
if (file.type !== undefined) fileAttrs += formatAttr('type', file.type)
if (file.mediaType !== undefined) fileAttrs += formatAttr('media_type', file.mediaType)
if (file.mimeType !== undefined) fileAttrs += formatAttr('mime_type', file.mimeType)
if (file.path !== undefined) fileAttrs += formatAttr('path', file.path)
lines.push(` <file${fileAttrs} />`)
}
lines.push(' </attached_files>')
}
// 6. <referenced_assets> ... </referenced_assets>
if (context.referencedAssets && context.referencedAssets.length > 0) {
const sortedAssets = [...context.referencedAssets].sort((a, b) => a.id.localeCompare(b.id))
lines.push(' <referenced_assets>')
for (const item of sortedAssets) {
if (item.type === 'folder') {
let folderAttrs = ''
if (item.id !== undefined) folderAttrs += formatAttr('id', item.id)
if (item.name !== undefined) folderAttrs += formatAttr('name', item.name)
if (item.path !== undefined) folderAttrs += formatAttr('path', item.path)
lines.push(` <folder${folderAttrs} />`)
} else {
let assetAttrs = ''
if (item.id !== undefined) assetAttrs += formatAttr('id', item.id)
if (item.name !== undefined) assetAttrs += formatAttr('name', item.name)
if (item.type !== undefined) assetAttrs += formatAttr('type', item.type)
if (item.mediaType !== undefined) assetAttrs += formatAttr('media_type', item.mediaType)
if (item.mimeType !== undefined) assetAttrs += formatAttr('mime_type', item.mimeType)
if (item.path !== undefined) assetAttrs += formatAttr('path', item.path)
lines.push(` <asset${assetAttrs} />`)
}
}
lines.push(' </referenced_assets>')
}
if (lines.length === 0) return ''
return `<context>\n${lines.join('\n')}\n</context>`
}
+1
View File
@@ -25,3 +25,4 @@ export * from './watermark'
export * from './quota'
export * from './kanban'
export * from './recents'
export * from './context'
+2 -1
View File
@@ -1,6 +1,7 @@
import { z } from 'zod'
import { UserType } from '@shumai/db/enums'
import { paginationPageInfoSchema, paginationParamsSchema } from './pagination'
import { assetTypeFilterSchema } from './asset'
export const createProjectRequestSchema = z.object({
name: z.string(),
@@ -58,7 +59,7 @@ export type ProjectUserInfo = z.infer<typeof projectUserInfoSchema>
export const recentlyDeletedRequestSchema = z
.object({
assetType: z.string(),
assetType: assetTypeFilterSchema.optional().default('all'),
sort: z.enum(['createdAt', 'name', 'size']).optional(),
order: z.enum(['asc', 'desc']).optional(),
})
+1 -1
View File
@@ -1,6 +1,6 @@
{
"name": "@shumai/e2e",
"version": "0.4.0",
"version": "0.4.1",
"private": true,
"type": "module",
"dependencies": {
@@ -1,146 +0,0 @@
import { describe, it, expect, beforeAll, afterAll, vi } from 'vitest'
import { prisma } from '@shumai/db'
import { setupTestDbHooks } from '@shumai/db/test'
import { workflowService, TaskQueueAgent } from '@shumai/workflow-core'
import { initAgentWorkflows } from '@shumai/agent'
import { s3Service } from '@shumai/core/src/s3/s3'
import { fileURLToPath } from 'url'
import * as path from 'path'
const currentDir = path.dirname(fileURLToPath(import.meta.url))
const agentWorkflowsPath = path.resolve(currentDir, '../../../apps/agent/src/workflows.ts')
describe.each(['local', 'temporal'] as const)(
'Workflow E2E - agentToolCall (executor: %s)',
(mode) => {
setupTestDbHooks()
let agentWorkerPromise: Promise<void> | null = null
beforeAll(async () => {
process.env.S3_BUCKET = 'shumai-e2e-test-bucket-toolcall'
process.env.GEMINI_API_KEY = 'dummy-key'
workflowService.setExecutorType(mode)
initAgentWorkflows()
if (mode === 'temporal') {
console.log('Starting background worker for tool call Temporal E2E tests...')
agentWorkerPromise = workflowService.startWorkers(TaskQueueAgent, {
workflowsPath: agentWorkflowsPath,
})
await new Promise((resolve) => setTimeout(resolve, 2000))
} else {
console.log('Starting local workflow service polling...')
workflowService.start()
}
})
afterAll(async () => {
if (mode === 'temporal') {
console.log('Shutting down Temporal workers...')
await workflowService.shutdownWorkers()
await Promise.all([agentWorkerPromise].filter(Boolean))
}
workflowService.close()
vi.restoreAllMocks()
try {
console.log('Cleaning up local E2E storage files...')
await s3Service.deletePrefix('shumai-e2e-test-bucket-toolcall', '')
} catch (err) {
console.error('Failed to clean up E2E storage folder:', err)
}
})
it('should run agentToolCall workflow and execute list_assets successfully', async () => {
// 1. Seed Database
const team = await prisma.team.create({
data: { name: 'E2E Tool Call Team' },
})
const project = await prisma.project.create({
data: { name: 'E2E Tool Call Project', teamId: team.id },
})
const regularUser = await prisma.user.create({
data: {
name: 'Regular Editor User',
email: 'editor@example.com',
type: 'human',
},
})
// Setup team member with owner/editor role and team scope
await prisma.teamMember.create({
data: {
teamId: team.id,
userId: regularUser.id,
role: 'editor',
scope: 'team',
},
})
// Create a folder asset (parent)
const parentFolder = await prisma.asset.create({
data: {
name: 'TestParentFolder',
type: 'folder',
status: 'processed',
projectId: project.id,
},
})
// Create a child file asset inside the parent folder
const childFile = await prisma.asset.create({
data: {
name: 'TestChildFile.png',
type: 'file',
status: 'uploaded',
mediaType: 'image/png',
projectId: project.id,
parentId: parentFolder.id,
},
})
// 2. Create Workflow Task
const task = await prisma.workflowTask.create({
data: {
type: 'agent_tool_call',
status: 'pending',
assetId: parentFolder.id,
projectId: project.id,
teamId: team.id,
payload: {
projectId: project.id,
agentToolCall: {
toolName: 'list_assets',
args: {
parent: parentFolder.id,
page: 1,
pageSize: 20,
type: 'all',
},
userId: regularUser.id,
},
},
},
})
// 3. Wait for workflow to complete
console.log(`Submitted E2E Tool Call Workflow Task. ID: ${task.id}. Awaiting completion...`)
const completedTask = await workflowService.executeWait(task, 45000)
// 4. Verification
expect(completedTask.status).toBe('completed')
// Verify task output contains the list of files, and childFile.id is present in assets
const output = completedTask.output as unknown as { assets: { id: string }[] }
expect(output).toBeDefined()
expect(output.assets).toBeDefined()
expect(output.assets.length).toBeGreaterThan(0)
const assetIds = output.assets.map((a) => a.id)
expect(assetIds).toContain(childFile.id)
}, 50000)
},
)
+1 -1
View File
@@ -1,6 +1,6 @@
{
"name": "@shumai/tableprinter",
"version": "0.4.0",
"version": "0.4.1",
"private": true,
"type": "module",
"main": "./src/index.ts",
+1 -1
View File
@@ -1,6 +1,6 @@
{
"name": "@shumai/transcode",
"version": "0.4.0",
"version": "0.4.1",
"private": true,
"type": "module",
"main": "./src/index.ts",
@@ -14,6 +14,7 @@ import { formatTimeAgo } from '@/ui/lib/time'
import { m } from '@/ui/paraglide/messages.js'
import { Terminal } from 'lucide-react'
import Markdown from 'react-markdown'
import { serializeContextToXml, type ShumaiMessageContext } from '@shumai/dtos'
interface AgentSessionLogsDialogProps {
sessionId?: string | null
@@ -87,14 +88,59 @@ export function AgentSessionLogsDialog({
}
if (piEntry && typeof piEntry === 'object') {
if (piEntry.type === 'custom_message') {
if (piEntry.customType === 'context') return null
if (piEntry.customType === 'shumai_message') {
const xml = serializeContextToXml(piEntry.details as ShumaiMessageContext)
const text = typeof piEntry.content === 'string' ? piEntry.content : ''
const fullText = xml ? `${text}\n\n${xml}`.trim() : text
const badgeColor = 'bg-primary/10 text-primary'
const roleName = m.role_user()
return (
<div key={entry.id} className="relative pl-6 pb-6 last:pb-0">
{/* Timeline Line */}
<div className="absolute left-[9px] top-2 bottom-0 w-0.5 bg-foreground/10 last:hidden" />
{/* Timeline Node */}
<div className="absolute left-0 top-1.5 h-5 w-5 rounded-full border-4 border-background flex items-center justify-center bg-primary" />
<div className="flex flex-col gap-1.5 bg-muted/30 dark:bg-muted/10 p-3 rounded-lg border border-foreground/5 backdrop-blur-xs w-full">
<div className="flex items-center justify-between gap-2">
<div className="flex items-center gap-2 flex-wrap">
<span
className={`text-[10px] px-2 py-0.5 rounded-full font-semibold uppercase tracking-wider ${badgeColor}`}
>
{roleName}
</span>
<span
className="text-[10px] font-mono text-muted-foreground bg-muted/50 px-1.5 py-0.5 rounded border border-foreground/10 select-all"
title={m.entry_id()}
>
{m.entry_id()}: {entry.id}
</span>
</div>
<span className="text-[10px] text-muted-foreground/60 shrink-0">
{timestamp}
</span>
</div>
<div className="text-xs text-foreground/90 whitespace-pre-wrap leading-relaxed font-sans">
{fullText}
</div>
</div>
</div>
)
}
}
if (piEntry.type === 'message' && piEntry.message) {
const msg = piEntry.message as Record<string, unknown>
let badgeColor = 'bg-gray-100 text-gray-800 dark:bg-gray-800 dark:text-gray-200'
let roleName: string = String(msg.role || '')
if (msg.role === 'user') {
badgeColor =
'bg-slate-100 text-slate-800 dark:bg-slate-900/30 dark:text-slate-300'
badgeColor = 'bg-primary/10 text-primary'
roleName = m.role_user()
} else if (msg.role === 'assistant') {
badgeColor =
@@ -283,7 +329,7 @@ export function AgentSessionLogsDialog({
<div
className={`absolute left-0 top-1.5 h-5 w-5 rounded-full border-4 border-background flex items-center justify-center ${
msg.role === 'user'
? 'bg-slate-500'
? 'bg-primary'
: msg.role === 'assistant'
? 'bg-violet-500'
: msg.role === 'toolResult'
@@ -304,9 +350,9 @@ export function AgentSessionLogsDialog({
</span>
<span
className="text-[10px] font-mono text-muted-foreground bg-muted/50 px-1.5 py-0.5 rounded border border-foreground/10 select-all"
title="Entry ID"
title={m.entry_id()}
>
ID: {entry.id}
{m.entry_id()}: {entry.id}
</span>
</div>
<span className="text-[10px] text-muted-foreground/60 shrink-0">
@@ -0,0 +1,101 @@
// @vitest-environment happy-dom
import React from 'react'
import { cleanup, render, screen, fireEvent } from '@testing-library/react'
import { afterEach, describe, expect, it, vi } from 'vitest'
import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
import type { CommentInfo } from '@shumai/dtos'
import { MessageCard } from './message-card'
function createWrapper() {
const queryClient = new QueryClient({
defaultOptions: { queries: { retry: false } },
})
return ({ children }: { children: React.ReactNode }) => (
<QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
)
}
describe('MessageCard component', () => {
afterEach(() => {
cleanup()
vi.clearAllMocks()
})
it('renders message text and attachment rows with 2x height for image and standard height for other files', () => {
const mockMessage: CommentInfo = {
id: 'msg-1',
assetId: 'asset-1',
message: 'Here is the feedback on design',
annotations: null,
second: null,
creator: { id: 'u-1', name: 'Bob Reviewer' },
replies: [],
attachments: [
{
id: 'att-img-1',
assetId: 'asset-1',
url: 'https://example.com/screenshot.png?AWSAccessKeyId=123',
proxyType: null,
},
{
id: 'att-doc-2',
assetId: 'asset-1',
url: 'https://example.com/notes.pdf?AWSAccessKeyId=123',
proxyType: null,
},
{
id: 'att-psd-3',
assetId: 'asset-1',
url: 'https://example.com/mockup.psd',
proxyType: null,
},
],
mentions: [],
createdAt: '2026-08-20T10:30:00.000Z',
updatedAt: '2026-08-20T10:30:00.000Z',
sessionId: null,
isCompleted: false,
completionLastChangedBy: null,
}
const onReply = vi.fn()
const getUser = vi.fn().mockReturnValue({ id: 'u-1', name: 'Bob Reviewer' })
render(<MessageCard message={mockMessage} getUser={getUser} onReply={onReply} />, {
wrapper: createWrapper(),
})
expect(screen.getByText('Here is the feedback on design')).toBeDefined()
expect(screen.getByText('screenshot.png')).toBeDefined()
expect(screen.getByText('notes.pdf')).toBeDefined()
expect(screen.getByText('mockup.psd')).toBeDefined()
// Verify row height classes: image row is h-18 (72px), file row is h-9 (36px)
const imgEl = screen.getByAltText('screenshot.png')
const imgRow = imgEl.closest('.group')
expect(imgRow?.className).toContain('h-18')
const fileEl = screen.getByText('notes.pdf')
const fileRow = fileEl.closest('.group')
expect(fileRow?.className).toContain('h-9')
// PSD should NOT be an image row (web browsers cannot render PSD in <img>)
const psdEl = screen.getByText('mockup.psd')
const psdRow = psdEl.closest('.group')
expect(psdRow?.className).toContain('h-9')
// Clicking image row opens image preview dialog
fireEvent.click(imgRow!)
expect(screen.getAllByAltText('screenshot.png').length).toBeGreaterThanOrEqual(2)
// Clicking file row opens URL in a new tab
const windowOpenSpy = vi.spyOn(window, 'open').mockImplementation(() => null)
fireEvent.click(fileRow!)
expect(windowOpenSpy).toHaveBeenCalledWith(
'https://example.com/notes.pdf?AWSAccessKeyId=123',
'_blank',
'noreferrer',
)
windowOpenSpy.mockRestore()
})
})
+64 -22
View File
@@ -16,10 +16,11 @@ import {
AlertDialogHeader,
AlertDialogTitle,
} from '@/ui/components/ui/alert-dialog'
import type { AttachmentInfo, CommentInfo, UserInfo } from '@shumai/dtos'
import { Dialog, DialogContent, DialogHeader, DialogTitle } from '@/ui/components/ui/dialog'
import type { CommentInfo, UserInfo } from '@shumai/dtos'
import type { MemberInfo } from '@/ui/stores/members'
import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'
import { Download, File, MoreHorizontal, Trash2 } from 'lucide-react'
import { Download, FileText, MoreHorizontal, Trash2 } from 'lucide-react'
import React from 'react'
import Markdown from 'react-markdown'
import { Avatar, AvatarFallback, AvatarImage } from '../ui/avatar'
@@ -30,6 +31,7 @@ import { m } from '@/ui/paraglide/messages.js'
import { useUiStore } from '@/ui/stores/ui'
import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from '../ui/tooltip'
import { AgentSessionLogsDialog } from '../agent/agent-session-logs-dialog'
import { isImageFileName } from '@/ui/lib/media'
interface MessageCardProps {
teamId?: string
@@ -39,7 +41,6 @@ interface MessageCardProps {
isLastReply?: boolean
getUser: (id: string) => MemberInfo | UserInfo
onReply: (message: CommentInfo) => void
onViewAttachment: (attachment: AttachmentInfo) => void
isSelected?: boolean
onSelect?: () => void
frameRate?: number
@@ -100,7 +101,6 @@ export const MessageCard: React.FC<MessageCardProps> = ({
isLastReply,
getUser,
onReply,
onViewAttachment,
isSelected,
onSelect,
frameRate,
@@ -116,6 +116,7 @@ export const MessageCard: React.FC<MessageCardProps> = ({
const loadingText = (message.message && AI_PLACEHOLDERS[message.message]) || 'Generating...'
const [isLogsOpen, setIsLogsOpen] = React.useState(false)
const [previewImage, setPreviewImage] = React.useState<{ url: string; name: string } | null>(null)
const { videoTimeDisplayMode } = useUiStore()
const displayTime = React.useMemo(() => {
@@ -325,39 +326,56 @@ export const MessageCard: React.FC<MessageCardProps> = ({
{/* Attachments */}
{message.attachments && message.attachments.length > 0 && (
<div className="flex flex-wrap gap-2 mt-3">
<div className="flex flex-col gap-1.5 mt-3 w-full max-w-full overflow-hidden">
{message.attachments.map((att) => {
const isImage = att.proxyType === 'image'
const name = att.url?.split('/').pop()?.split('?')[0] || 'file'
const rawName = att.url?.split('/').pop()?.split('?')[0] || 'file'
const name = decodeURIComponent(rawName)
const isImage = isImageFileName(name)
return (
<div
key={att.id}
className="relative group rounded-lg overflow-hidden border bg-white shadow-sm hover:shadow-md transition-shadow w-48 h-32"
onClick={() => isImage && onViewAttachment(att)}
className={`group relative flex items-center w-full max-w-full rounded-lg border border-border bg-card hover:bg-muted/40 transition-colors overflow-hidden ${
isImage ? 'h-18 p-1.5 gap-2.5 cursor-pointer' : 'h-9 px-2.5 gap-2.5'
}`}
onClick={() => {
if (isImage) {
setPreviewImage({ url: att.url, name })
} else {
window.open(att.url, '_blank', 'noreferrer')
}
}}
>
{isImage ? (
<img
src={att.url}
alt={name}
className="w-full h-full object-cover cursor-pointer"
/>
) : (
<div className="w-full h-full bg-gray-100 flex flex-col items-center justify-center p-2 text-center">
<File className="w-8 h-8 text-gray-500 mb-2" />
<span className="text-xs font-medium text-gray-700 break-all line-clamp-2">
{name}
</span>
<div className="h-full aspect-square rounded-md overflow-hidden bg-muted/40 shrink-0">
<img
src={att.url}
alt={name}
className="w-full h-full object-cover group-hover:scale-105 transition-transform duration-200"
/>
</div>
) : (
<FileText className="w-4 h-4 text-muted-foreground shrink-0" />
)}
<div className="min-w-0 flex-1 overflow-hidden">
<p
className="text-xs font-medium text-foreground truncate block w-full"
title={name}
>
{name}
</p>
</div>
<a
href={att.url}
target="_blank"
rel="noreferrer"
download={name}
className="absolute right-2 bottom-2 bg-black/60 text-white hover:bg-black/80 p-1.5 rounded-full opacity-0 group-hover:opacity-100 transition-opacity"
className="p-1 text-muted-foreground hover:text-foreground shrink-0 rounded-md hover:bg-muted transition-colors opacity-0 group-hover:opacity-100"
onClick={(e) => e.stopPropagation()}
title={m.download()}
>
<Download className="w-4 h-4" />
<Download className="w-3.5 h-3.5" />
</a>
</div>
)
@@ -458,6 +476,30 @@ export const MessageCard: React.FC<MessageCardProps> = ({
</AlertDialogFooter>
</AlertDialogContent>
</AlertDialog>
{/* Image Preview Dialog */}
<Dialog open={!!previewImage} onOpenChange={(open) => !open && setPreviewImage(null)}>
<DialogContent
className="w-auto max-w-[80vw] sm:max-w-[80vw] max-h-[80vh] p-2 sm:p-3 bg-background/95 backdrop-blur-sm border-border flex flex-col items-center justify-center overflow-hidden"
onClick={(e) => e.stopPropagation()}
>
<DialogHeader className="sr-only">
<DialogTitle>{previewImage?.name || 'Image Preview'}</DialogTitle>
</DialogHeader>
{previewImage && (
<div className="flex flex-col items-center justify-center max-w-[80vw] max-h-[80vh] overflow-hidden">
<img
src={previewImage.url}
alt={previewImage.name}
className="max-w-[80vw] max-h-[calc(80vh-2.5rem)] w-auto h-auto object-contain rounded-md"
/>
<p className="text-xs text-muted-foreground truncate max-w-full px-2 pt-1.5 text-center">
{previewImage.name}
</p>
</div>
)}
</DialogContent>
</Dialog>
</div>
)
}
+32 -2
View File
@@ -12,7 +12,7 @@ import { m } from '@/ui/paraglide/messages.js'
import { useChatbotStore } from '@/ui/stores/chatbot'
import { useTeamContextStore } from '@/ui/stores/team-context'
import { useDroppable } from '@dnd-kit/react'
import type { ChatMessage } from '@shumai/dtos'
import type { ChatMessage, ShumaiMessageContext } from '@shumai/dtos'
import { useQuery, useQueryClient } from '@tanstack/react-query'
import {
ArrowLeft,
@@ -401,6 +401,31 @@ export function ChatbotSidebar({ projectId, contextAssetId }: ChatbotSidebarProp
case 'thinking_level_change':
case 'custom': {
const msgObj = msg as unknown as Record<string, unknown>
if (msgObj.customType === 'shumai_message') {
const details = msgObj.details as ShumaiMessageContext | undefined
const referencedAssets = details?.referencedAssets || []
return (
<div key={msg.id} className="flex flex-col items-end w-full space-y-1">
{referencedAssets.length > 0 && (
<div className="text-xs text-muted-foreground bg-muted/40 p-2.5 rounded-lg border border-border/50 space-y-1 my-1 w-full">
<div className="font-semibold">{m.assets_added_to_context()}</div>
<ul className="list-disc list-inside space-y-0.5">
{referencedAssets.map((asset) => (
<li key={asset.id} className="truncate">
{asset.name}{' '}
<span className="text-muted-foreground/70">({asset.type})</span>
</li>
))}
</ul>
</div>
)}
<div className="bg-primary text-primary-foreground rounded-lg px-3 py-2 max-w-[85%] text-sm whitespace-pre-wrap shadow-xs break-words">
{getMessageText(msgObj.content)}
</div>
</div>
)
}
if (msgObj.customType === 'context_display_info') {
const details = msgObj.details as
| { assets?: Array<{ id: string; name: string; type: string }> }
@@ -561,7 +586,12 @@ export function ChatbotSidebar({ projectId, contextAssetId }: ChatbotSidebarProp
{messages.map(renderMessage)}
{isStreaming &&
messages.length > 0 &&
messages[messages.length - 1].role === 'user' && (
(messages[messages.length - 1].role === 'user' ||
(
messages[messages.length - 1] as unknown as {
customType?: string
}
).customType === 'shumai_message') && (
<div className="flex items-center gap-1.5 text-xs text-muted-foreground italic">
<Loader2 className="h-3 w-3 animate-spin text-primary" />
<span>Thinking...</span>
+1
View File
@@ -2,5 +2,6 @@ export interface DragState {
isActive: boolean
draggedIds: Set<string>
hasFolders: boolean
isSingleFile: boolean
itemCount: number
}
@@ -0,0 +1,83 @@
// @vitest-environment happy-dom
import { cleanup, fireEvent, render, screen } from '@testing-library/react'
import React from 'react'
import { afterEach, describe, expect, it, vi } from 'vitest'
import { FileBrowserContextMenu } from './context-menu'
import { ContextMenu, ContextMenuTrigger } from '@/ui/components/ui/context-menu'
import type { AssetInfo } from '@shumai/dtos'
describe('FileBrowserContextMenu', () => {
afterEach(() => {
cleanup()
})
const stackItem: AssetInfo = {
id: 'stack-123',
name: 'version_stack_test',
type: 'version_stack',
status: 'processed',
fileCount: 2,
createdAt: '2026-01-01T00:00:00Z',
updatedAt: '2026-01-01T00:00:00Z',
} as AssetInfo
const fileItem: AssetInfo = {
id: 'file-123',
name: 'regular_file.png',
type: 'file',
status: 'processed',
createdAt: '2026-01-01T00:00:00Z',
updatedAt: '2026-01-01T00:00:00Z',
} as AssetInfo
const renderWithMenu = (
item: AssetInfo,
props: Partial<React.ComponentProps<typeof FileBrowserContextMenu>> = {},
) => {
return render(
<ContextMenu>
<ContextMenuTrigger data-testid="context-trigger">Trigger</ContextMenuTrigger>
<FileBrowserContextMenu
item={item}
selectedIds={new Set()}
folders={[]}
files={[item]}
onRename={vi.fn()}
onDelete={vi.fn()}
onDownload={vi.fn()}
onRestore={vi.fn()}
onNewFolder={vi.fn()}
onUploadFile={vi.fn()}
onUploadFolder={vi.fn()}
onNewVersion={vi.fn()}
onManageVersions={vi.fn()}
onMoveTo={vi.fn()}
onCopyTo={vi.fn()}
canEdit={true}
{...props}
/>
</ContextMenu>,
)
}
it('renders Manage versions for version_stack item when canEdit is true', () => {
const onManageVersions = vi.fn()
renderWithMenu(stackItem, { onManageVersions })
fireEvent.contextMenu(screen.getByTestId('context-trigger'))
const manageOption = screen.getByText(/Manage versions|管理版本/i)
expect(manageOption).toBeTruthy()
fireEvent.click(manageOption)
expect(onManageVersions).toHaveBeenCalledWith(stackItem)
})
it('does not render Manage versions for regular file item', () => {
renderWithMenu(fileItem)
fireEvent.contextMenu(screen.getByTestId('context-trigger'))
expect(screen.queryByText(/Manage versions|管理版本/i)).toBeNull()
})
})
@@ -22,6 +22,7 @@ import {
Plus,
ArrowRight,
Copy,
Layers,
} from 'lucide-react'
interface FileBrowserContextMenuProps {
@@ -36,6 +37,7 @@ interface FileBrowserContextMenuProps {
onUploadFile: () => void
onUploadFolder: () => void
onNewVersion: (item: AssetInfo) => void
onManageVersions?: (item: AssetInfo) => void
onMoveTo: (items: AssetInfo[]) => void
onCopyTo: (items: AssetInfo[]) => void
folders: AssetInfo[]
@@ -63,6 +65,7 @@ export function FileBrowserContextMenu({
onUploadFile,
onUploadFolder,
onNewVersion,
onManageVersions,
onMoveTo,
onCopyTo,
folders,
@@ -296,6 +299,13 @@ export function FileBrowserContextMenu({
</ContextMenuItem>
)}
{canEdit && item.type === 'version_stack' && (
<ContextMenuItem onSelect={() => onManageVersions?.(item)}>
<Layers className="mr-2 h-4 w-4" />
<span>{m.manage_versions()}</span>
</ContextMenuItem>
)}
{item.type === 'folder' && onOpenAgentsMd && (
<ContextMenuItem onSelect={() => onOpenAgentsMd(item)}>
<FileText className="mr-2 h-4 w-4" />
@@ -0,0 +1,202 @@
// @vitest-environment happy-dom
import { cleanup, render, screen } from '@testing-library/react'
import React from 'react'
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
import { FileBrowser } from './file-browser'
import type { AssetInfo } from '@shumai/dtos'
import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
vi.mock('@tanstack/react-router', () => ({
useNavigate: () => vi.fn(),
}))
vi.mock('@tanstack/react-virtual', () => ({
useVirtualizer: (options: { count: number }) => ({
getVirtualItems: () =>
Array.from({ length: options.count }, (_, i) => ({
index: i,
start: i * 50,
size: 50,
key: i,
})),
getTotalSize: () => options.count * 50,
}),
}))
vi.mock('@dnd-kit/react', () => ({
useDraggable: () => ({
ref: vi.fn(),
isDragging: false,
}),
useDroppable: () => ({
ref: vi.fn(),
isOver: false,
}),
}))
vi.mock('@/ui/hooks/use-permissions', () => ({
usePermissions: () => ({
canEdit: true,
canAdmin: true,
canView: true,
}),
}))
vi.mock('@/ui/api/client', () => ({
client: {
api: {
files: {
$delete: vi.fn().mockResolvedValue({ ok: true, json: async () => ({}) }),
'download-links': {
$post: vi.fn().mockResolvedValue({ ok: true, json: async () => ({ files: [] }) }),
},
restore: {
$post: vi.fn().mockResolvedValue({ ok: true, json: async () => ({}) }),
},
':fileId': {
$get: vi.fn().mockResolvedValue({
ok: true,
json: async () => ({}),
}),
$put: vi.fn().mockResolvedValue({
ok: true,
json: async () => ({}),
}),
},
},
folders: {
$post: vi.fn().mockResolvedValue({
ok: true,
json: async () => ({ id: 'new-folder-id' }),
}),
$delete: vi.fn().mockResolvedValue({ ok: true, json: async () => ({}) }),
restore: {
$post: vi.fn().mockResolvedValue({ ok: true, json: async () => ({}) }),
},
':folderId': {
$put: vi.fn().mockResolvedValue({ ok: true, json: async () => ({}) }),
},
},
teams: {
':teamId': {
upload: {
tasks: {
$post: vi.fn().mockResolvedValue({ ok: true, json: async () => ({}) }),
':taskId': {
$patch: vi.fn().mockResolvedValue({ ok: true, json: async () => ({}) }),
},
},
},
},
},
projects: {
':projectId': {
'empty-trash': {
$post: vi.fn().mockResolvedValue({ ok: true, json: async () => ({}) }),
},
shares: {
$get: vi.fn().mockResolvedValue({ ok: true, json: async () => ({ data: [] }) }),
$post: vi.fn().mockResolvedValue({ ok: true, json: async () => ({ id: 'share-1' }) }),
},
reparent: {
$post: vi.fn().mockResolvedValue({ ok: true, json: async () => ({}) }),
},
copy: {
$post: vi.fn().mockResolvedValue({ ok: true, json: async () => ({}) }),
},
},
},
},
},
}))
describe('FileBrowser', () => {
let queryClient: QueryClient
beforeEach(() => {
queryClient = new QueryClient({
defaultOptions: { queries: { retry: false } },
})
})
afterEach(() => {
cleanup()
})
const mockFolder: AssetInfo = {
id: 'folder-1',
name: 'Test Folder',
type: 'folder',
fileCount: 3,
sizeByte: 0,
createdAt: '2026-01-01T00:00:00Z',
updatedAt: '2026-01-01T00:00:00Z',
status: 'processed',
} as AssetInfo
const mockFile: AssetInfo = {
id: 'file-1',
name: 'test_document.pdf',
type: 'file',
sizeByte: 1024 * 100,
createdAt: '2026-01-01T00:00:00Z',
updatedAt: '2026-01-01T00:00:00Z',
status: 'processed',
} as AssetInfo
const defaultProps = {
teamId: 'team-1',
projectId: 'project-1',
assetId: 'root-folder',
folders: [mockFolder],
files: [mockFile],
selectedItem: null,
selectedIds: new Set<string>(),
onItemSelect: vi.fn(),
onItemDoubleClick: vi.fn(),
onSaveField: vi.fn(),
displayStyle: 'card' as const,
onClearSelection: vi.fn(),
fetchNextFoldersPage: vi.fn(),
hasNextFoldersPage: false,
isFetchingNextFoldersPage: false,
fetchNextFilesPage: vi.fn(),
hasNextFilesPage: false,
isFetchingNextFilesPage: false,
}
const renderComponent = (props: Partial<React.ComponentProps<typeof FileBrowser>> = {}) => {
return render(
<QueryClientProvider client={queryClient}>
<FileBrowser {...defaultProps} {...props} />
</QueryClientProvider>,
)
}
it('renders folders and files in card view', () => {
renderComponent()
expect(screen.getByText('Test Folder')).toBeDefined()
expect(screen.getByText('test_document.pdf')).toBeDefined()
})
it('renders empty state when there are no folders and files and not loading', () => {
renderComponent({ folders: [], files: [], isLoading: false })
expect(screen.getByText(/This folder is empty|此文件夹为空/i)).toBeDefined()
})
it('renders loading skeleton and does not render empty state when isLoading is true (card view)', () => {
renderComponent({ folders: [], files: [], isLoading: true, displayStyle: 'card' })
expect(screen.queryByText(/This folder is empty|此文件夹为空/i)).toBeNull()
expect(screen.getByTestId('file-browser-loading-skeleton')).toBeDefined()
})
it('renders loading skeleton and does not render empty state when isLoading is true (list view)', () => {
renderComponent({ folders: [], files: [], isLoading: true, displayStyle: 'list' })
expect(screen.queryByText(/This folder is empty|此文件夹为空/i)).toBeNull()
expect(screen.getByTestId('file-browser-loading-skeleton')).toBeDefined()
})
})
@@ -25,6 +25,8 @@ import { toast } from 'sonner'
import { ulid } from 'ulid'
import type { DragState } from '../dnd-types'
import { MoveCopyDialog } from '../move-copy-dialog'
import { ManageVersionsDialog } from '../manage-versions-dialog'
import { FileBrowserContentSkeleton } from '../loading-skeletons'
import { FileBrowserContextMenu } from './context-menu'
import {
@@ -80,6 +82,7 @@ interface FileBrowserProps {
isFetchingNextFilesPage: boolean
isRecentlyDeleted?: boolean
isRecents?: boolean
isLoading?: boolean
filterConditions?: SearchCondition[]
onFilterChange?: (conditions: SearchCondition[]) => void
sort?: SearchSort
@@ -130,6 +133,7 @@ export function FileBrowser({
isFetchingNextFilesPage,
isRecentlyDeleted,
isRecents,
isLoading = false,
filterConditions,
onFilterChange,
sort,
@@ -146,6 +150,7 @@ export function FileBrowser({
allowDownload = true,
}: FileBrowserProps) {
const [contextMenuItem, setContextMenuItem] = useState<AssetInfo | null>(null)
const [manageVersionsStackId, setManageVersionsStackId] = useState<string | null>(null)
const [moveCopyMode, setMoveCopyMode] = useState<'move' | 'copy' | null>(null)
const [itemsToMoveCopy, setItemsToMoveCopy] = useState<AssetInfo[]>([])
const queryClient = useQueryClient()
@@ -671,6 +676,10 @@ export function FileBrowser({
},
dragState,
onAction: (action: string, item: AssetInfo) => {
if (action === 'manage-versions') {
setManageVersionsStackId(item.id || null)
return
}
if (isShareView) {
if (action === 'remove-from-share') {
const isSelected = selectedIds.has(item.id!)
@@ -1046,7 +1055,9 @@ export function FileBrowser({
className="flex-1 overflow-y-auto min-h-0 relative flex flex-col"
style={{ overflowAnchor: 'none' }}
>
{displayStyle === 'list' ? (
{isLoading && folders.length === 0 && displayedFiles.length === 0 ? (
<FileBrowserContentSkeleton displayStyle={displayStyle} />
) : displayStyle === 'list' ? (
<FileBrowserListView
folders={folders}
files={displayedFiles}
@@ -1115,11 +1126,12 @@ export function FileBrowser({
{(isFetchingNextFoldersPage || isFetchingNextFilesPage) && (
<div className="flex justify-center items-center p-4">
<p>Loading more...</p>
<p>{m.loading_more()}</p>
</div>
)}
{folders.length === 0 &&
{!isLoading &&
folders.length === 0 &&
displayedFiles.length === 0 &&
!isFetchingNextFoldersPage &&
!isFetchingNextFilesPage && (
@@ -1133,7 +1145,7 @@ export function FileBrowser({
</p>
</div>
) : (
<span>This folder is empty</span>
<span>{m.this_folder_is_empty()}</span>
)}
</div>
)}
@@ -1200,6 +1212,7 @@ export function FileBrowser({
onUploadFile={handleUploadFilesClick}
onUploadFolder={handleUploadFolderClick}
onNewVersion={handleNewVersionClick}
onManageVersions={(item) => setManageVersionsStackId(item.id || null)}
onMoveTo={(items) => {
setItemsToMoveCopy(items)
setMoveCopyMode('move')
@@ -1368,6 +1381,20 @@ export function FileBrowser({
</DialogFooter>
</DialogContent>
</Dialog>
{manageVersionsStackId && (
<ManageVersionsDialog
open={!!manageVersionsStackId}
onOpenChange={(open) => {
if (!open) setManageVersionsStackId(null)
}}
stackId={manageVersionsStackId}
canEdit={canEdit}
onStackDissolved={() => {
setManageVersionsStackId(null)
}}
/>
)}
</>
)
}
@@ -0,0 +1,113 @@
// @vitest-environment happy-dom
import { cleanup, fireEvent, render, screen } from '@testing-library/react'
import React from 'react'
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
import { FileCard } from './file-card'
import type { AssetInfo } from '@shumai/dtos'
import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
vi.mock('@dnd-kit/react', () => ({
useDraggable: () => ({
ref: vi.fn(),
isDragging: false,
}),
useDroppable: () => ({
ref: vi.fn(),
isDropTarget: false,
}),
}))
vi.mock('@/ui/api/client', () => ({
client: {
api: {
files: {
':fileId': {
$get: vi.fn().mockResolvedValue({
ok: true,
json: async () => ({}),
}),
},
},
},
},
}))
describe('FileCard', () => {
let queryClient: QueryClient
beforeEach(() => {
queryClient = new QueryClient({
defaultOptions: { queries: { retry: false } },
})
})
afterEach(() => {
cleanup()
})
const stackItem: AssetInfo = {
id: 'stack-123',
name: 'version_stack_test',
type: 'version_stack',
status: 'processed',
fileCount: 2,
createdAt: '2026-01-01T00:00:00Z',
updatedAt: '2026-01-01T00:00:00Z',
} as AssetInfo
const fileItem: AssetInfo = {
id: 'file-123',
name: 'regular_file.png',
type: 'file',
status: 'processed',
createdAt: '2026-01-01T00:00:00Z',
updatedAt: '2026-01-01T00:00:00Z',
} as AssetInfo
const renderComponent = (props: Partial<React.ComponentProps<typeof FileCard>> = {}) => {
return render(
<QueryClientProvider client={queryClient}>
<FileCard
item={stackItem}
isSelected={false}
isChecked={false}
isEditing={false}
onSelect={vi.fn()}
onDoubleClick={vi.fn()}
onContextMenu={vi.fn()}
onDragStart={vi.fn()}
onDrop={vi.fn()}
onRename={vi.fn()}
onFinishEditing={vi.fn()}
onSaveField={vi.fn()}
fields={[]}
canEdit={true}
{...props}
/>
</QueryClientProvider>,
)
}
it('renders Manage versions in 3-dot dropdown menu for version_stack item', () => {
const onAction = vi.fn()
renderComponent({ item: stackItem, onAction })
const moreBtn = screen.getByRole('button', { name: '' })
fireEvent.keyDown(moreBtn, { key: 'ArrowDown', code: 'ArrowDown' })
const manageItem = screen.getByText(/Manage versions|管理版本/i)
expect(manageItem).toBeTruthy()
fireEvent.click(manageItem)
expect(onAction).toHaveBeenCalledWith('manage-versions', stackItem)
})
it('does not render Manage versions in 3-dot dropdown menu for regular file item', () => {
renderComponent({ item: fileItem })
const moreBtn = screen.getByRole('button', { name: '' })
fireEvent.keyDown(moreBtn, { key: 'ArrowDown', code: 'ArrowDown' })
expect(screen.queryByText(/Manage versions|管理版本/i)).toBeNull()
})
})
@@ -21,7 +21,7 @@ import { selectFileNameWithoutExtension } from '@/ui/lib/rename-utils'
import { cn } from '@/ui/lib/utils'
import { useUploadStore } from '@/ui/stores/upload'
import { useDraggable, useDroppable } from '@dnd-kit/react'
import { Download, Edit, History, MoreHorizontal, Trash2 } from 'lucide-react'
import { Download, Edit, History, Layers, MoreHorizontal, Trash2 } from 'lucide-react'
import React, { useEffect, useMemo, useRef, useState } from 'react'
import type { DragState } from '../dnd-types'
import FieldRenderer from '../field-renderer'
@@ -48,7 +48,7 @@ interface FileCardProps {
dragState?: DragState
disabled?: boolean
onAction?: (
action: 'rename' | 'delete' | 'download' | 'restore' | 'remove-from-share',
action: 'rename' | 'delete' | 'download' | 'restore' | 'remove-from-share' | 'manage-versions',
item: AssetInfo,
) => void
isRecentlyDeleted?: boolean
@@ -133,7 +133,7 @@ export function FileCard({
const { ref: setDraggableRef, isDragging: isDraggableDragging } = useDraggable({
id: `browser:${displayItem.id!}`,
data: {
type: 'file',
type: displayItem.type,
id: displayItem.id,
item: displayItem,
},
@@ -143,7 +143,7 @@ export function FileCard({
const { ref: setDroppableRef, isDropTarget: isOver } = useDroppable({
id: `browser:${displayItem.id!}`,
data: {
type: 'file',
type: displayItem.type,
id: displayItem.id,
item: displayItem,
},
@@ -160,14 +160,12 @@ export function FileCard({
isDraggableDragging || (dragState?.draggedIds.has(displayItem.id!) ?? false)
// Determine if this is a valid drop target
// File target is valid ONLY if dragging 1 item AND it is a file (version stack)
// File/version stack target is valid ONLY if dragging 1 single regular file
// And strictly, we shouldn't drop on ourselves
const isValidDropTarget = useMemo(() => {
if (!dragState?.isActive) return false
if (dragState.draggedIds.has(displayItem.id!)) return false // Can't drop on self
if (dragState.hasFolders) return false // Can't drag folders onto file
if (dragState.itemCount !== 1) return false // Can't drag multiple files onto file
return true
return dragState.isSingleFile
}, [dragState, displayItem.id])
const showDropFeedback = isOver && isValidDropTarget
@@ -377,6 +375,17 @@ export function FileCard({
<span>{m.rename()}</span>
</DropdownMenuItem>
)}
{canEdit && item.type === 'version_stack' && (
<DropdownMenuItem
onClick={(e) => {
e.stopPropagation()
onAction?.('manage-versions', item)
}}
>
<Layers className="mr-2 h-4 w-4" />
<span>{m.manage_versions()}</span>
</DropdownMenuItem>
)}
{allowDownload && (
<DropdownMenuItem
onClick={(e) => {
@@ -108,7 +108,7 @@ export function FileListItem({
const { ref: setDraggableRef, isDragging: isDraggableDragging } = useDraggable({
id: `browser:${displayItem.id!}`,
data: {
type: displayItem.type === 'folder' ? 'folder' : 'file',
type: displayItem.type,
id: displayItem.id,
item: displayItem,
},
@@ -72,7 +72,7 @@ function ListRow({
const { ref: setRowRef, isDropTarget: isRowOver } = useDroppable({
id: `browser:${item.id!}`,
data: {
type: item.type === 'folder' ? 'folder' : 'file',
type: item.type,
id: item.id,
item: item,
},
@@ -85,10 +85,8 @@ function ListRow({
if (item.type === 'folder') return true
if (item.type === 'file') {
if (dragState.hasFolders) return false
if (dragState.itemCount !== 1) return false
return true
if (item.type === 'file' || item.type === 'version_stack') {
return dragState.isSingleFile
}
return false
@@ -171,12 +171,19 @@ describe('MobileFileBrowser', () => {
expect(onItemDoubleClick).toHaveBeenCalledWith(mockFolder)
})
it('renders empty state when there are no folders and files', () => {
renderComponent({ folders: [], files: [] })
it('renders empty state when there are no folders and files and not loading', () => {
renderComponent({ folders: [], files: [], isLoading: false })
expect(screen.getByText(/This folder is empty|此文件夹为空/i)).toBeDefined()
})
it('renders loading skeleton and does not render empty state when isLoading is true', () => {
renderComponent({ folders: [], files: [], isLoading: true })
expect(screen.queryByText(/This folder is empty|此文件夹为空/i)).toBeNull()
expect(screen.getByTestId('mobile-file-browser-loading-skeleton')).toBeDefined()
})
it('renders collapsible section headers for folders and files with count and size', () => {
renderComponent({
totalFoldersSize: 50000,
@@ -52,6 +52,7 @@ import { Input } from '../ui/input'
import { FileCard } from './file-card'
import { FolderCard } from './folder-card'
import { useFileActions } from './use-file-actions'
import { MobileFileBrowserContentSkeleton } from '../loading-skeletons'
export interface MobileFileBrowserProps {
teamId: string
@@ -77,6 +78,7 @@ export interface MobileFileBrowserProps {
isFetchingNextFilesPage: boolean
isRecentlyDeleted?: boolean
isRecents?: boolean
isLoading?: boolean
isShareView?: boolean
isPublic?: boolean
shareId?: string
@@ -115,6 +117,7 @@ export function MobileFileBrowser({
isFetchingNextFilesPage,
isRecentlyDeleted = false,
isRecents = false,
isLoading = false,
isShareView = false,
isPublic = false,
shareId,
@@ -471,6 +474,7 @@ export function MobileFileBrowser({
}
const isFolderEmpty =
!isLoading &&
folders.length === 0 &&
files.length === 0 &&
!isFetchingNextFoldersPage &&
@@ -527,110 +531,114 @@ export function MobileFileBrowser({
{/* Main scroll area */}
<div className="flex-1 overflow-y-auto min-h-0 p-3 pb-24">
<div className="max-w-lg mx-auto w-full">
{/* Folders Section */}
{foldersCount > 0 && (
<div className="mb-4">
<button
onClick={() => setFoldersExpanded(!foldersExpanded)}
className="flex items-center gap-2 text-sm text-muted-foreground hover:text-foreground mb-3 font-medium select-none cursor-pointer"
>
{foldersExpanded ? (
<ChevronDown className="h-4 w-4" />
) : (
<ChevronRight className="h-4 w-4" />
{isLoading && folders.length === 0 && files.length === 0 ? (
<MobileFileBrowserContentSkeleton />
) : (
<div className="max-w-lg mx-auto w-full">
{/* Folders Section */}
{foldersCount > 0 && (
<div className="mb-4">
<button
onClick={() => setFoldersExpanded(!foldersExpanded)}
className="flex items-center gap-2 text-sm text-muted-foreground hover:text-foreground mb-3 font-medium select-none cursor-pointer"
>
{foldersExpanded ? (
<ChevronDown className="h-4 w-4" />
) : (
<ChevronRight className="h-4 w-4" />
)}
<span>
{formatCount(foldersCount, false)}
{showFoldersSize ? ` • ${formatSize(foldersSizeVal)}` : ''}
</span>
</button>
{foldersExpanded && (
<div className="grid grid-cols-1 gap-4 w-full">
{folders.map((folder) => (
<FolderCard
key={folder.id}
item={folder}
isSelected={selectedItem?.id === folder.id}
isChecked={selectedIds.has(folder.id!)}
isEditing={editingItemId === folder.id}
onSelect={onItemSelect}
onDoubleClick={onItemDoubleClick}
onContextMenu={() => {}}
onDragStart={() => {}}
onDrop={() => {}}
onRename={(newName) => onRenameSubmit(folder, newName)}
onFinishEditing={() => setEditingItemId(null)}
onAction={(action, item) =>
handleAction(action as 'rename' | 'delete' | 'download' | 'restore', item)
}
isRecentlyDeleted={isRecentlyDeleted}
isRecents={isRecents}
selectedCount={selectedIds.size}
canEdit={canEdit}
isShareView={isShareView}
allowDownload={allowDownload}
/>
))}
</div>
)}
<span>
{formatCount(foldersCount, false)}
{showFoldersSize ? ` • ${formatSize(foldersSizeVal)}` : ''}
</span>
</button>
</div>
)}
{foldersExpanded && (
<div className="grid grid-cols-1 gap-4 w-full">
{folders.map((folder) => (
<FolderCard
key={folder.id}
item={folder}
isSelected={selectedItem?.id === folder.id}
isChecked={selectedIds.has(folder.id!)}
isEditing={editingItemId === folder.id}
onSelect={onItemSelect}
onDoubleClick={onItemDoubleClick}
onContextMenu={() => {}}
onDragStart={() => {}}
onDrop={() => {}}
onRename={(newName) => onRenameSubmit(folder, newName)}
onFinishEditing={() => setEditingItemId(null)}
onAction={(action, item) =>
handleAction(action as 'rename' | 'delete' | 'download' | 'restore', item)
}
isRecentlyDeleted={isRecentlyDeleted}
isRecents={isRecents}
selectedCount={selectedIds.size}
canEdit={canEdit}
isShareView={isShareView}
allowDownload={allowDownload}
/>
))}
</div>
)}
</div>
)}
{/* Files Section */}
{filesCount > 0 && (
<div className="mb-4">
<button
onClick={() => setFilesExpanded(!filesExpanded)}
className="flex items-center gap-2 text-sm text-muted-foreground hover:text-foreground mb-3 font-medium select-none cursor-pointer"
>
{filesExpanded ? (
<ChevronDown className="h-4 w-4" />
) : (
<ChevronRight className="h-4 w-4" />
)}
<span>
{formatCount(filesCount, true)}
{showFilesSize ? ` • ${formatSize(filesSizeVal)}` : ''}
</span>
</button>
{/* Files Section */}
{filesCount > 0 && (
<div className="mb-4">
<button
onClick={() => setFilesExpanded(!filesExpanded)}
className="flex items-center gap-2 text-sm text-muted-foreground hover:text-foreground mb-3 font-medium select-none cursor-pointer"
>
{filesExpanded ? (
<ChevronDown className="h-4 w-4" />
) : (
<ChevronRight className="h-4 w-4" />
{filesExpanded && (
<div className="grid grid-cols-1 gap-4 w-full">
{files.map((file) => (
<FileCard
key={file.id}
teamId={teamId}
item={file}
isSelected={selectedItem?.id === file.id}
isChecked={selectedIds.has(file.id!)}
isEditing={editingItemId === file.id}
onSelect={onItemSelect}
onDoubleClick={onItemDoubleClick}
onContextMenu={() => {}}
onDragStart={() => {}}
onDrop={() => {}}
onRename={(newName) => onRenameSubmit(file, newName)}
onFinishEditing={() => setEditingItemId(null)}
onSaveField={(fieldId, value) => onSaveField?.(file.id!, fieldId, value)}
fields={[]}
onAction={(action, item) =>
handleAction(action as 'rename' | 'delete' | 'download' | 'restore', item)
}
isRecentlyDeleted={isRecentlyDeleted}
isRecents={isRecents}
selectedCount={selectedIds.size}
canEdit={canEdit}
isShareView={isShareView}
allowDownload={allowDownload}
/>
))}
</div>
)}
<span>
{formatCount(filesCount, true)}
{showFilesSize ? ` • ${formatSize(filesSizeVal)}` : ''}
</span>
</button>
{filesExpanded && (
<div className="grid grid-cols-1 gap-4 w-full">
{files.map((file) => (
<FileCard
key={file.id}
teamId={teamId}
item={file}
isSelected={selectedItem?.id === file.id}
isChecked={selectedIds.has(file.id!)}
isEditing={editingItemId === file.id}
onSelect={onItemSelect}
onDoubleClick={onItemDoubleClick}
onContextMenu={() => {}}
onDragStart={() => {}}
onDrop={() => {}}
onRename={(newName) => onRenameSubmit(file, newName)}
onFinishEditing={() => setEditingItemId(null)}
onSaveField={(fieldId, value) => onSaveField?.(file.id!, fieldId, value)}
fields={[]}
onAction={(action, item) =>
handleAction(action as 'rename' | 'delete' | 'download' | 'restore', item)
}
isRecentlyDeleted={isRecentlyDeleted}
isRecents={isRecents}
selectedCount={selectedIds.size}
canEdit={canEdit}
isShareView={isShareView}
allowDownload={allowDownload}
/>
))}
</div>
)}
</div>
)}
</div>
</div>
)}
</div>
)}
{/* Empty state */}
{isFolderEmpty && (
@@ -202,6 +202,7 @@ export default function FileSystemManager({
fetchNextPage: fetchNextFoldersPage,
hasNextPage: hasNextPageFolders,
isFetchingNextPage: isFetchingNextFoldersPage,
isLoading: isFoldersLoading,
} = useInfiniteQuery<AssetInfoPaginatedList>({
queryKey: isRecentlyDeleted
? ['projects', projectId, 'recently-deleted', 'folder']
@@ -252,6 +253,7 @@ export default function FileSystemManager({
fetchNextPage: fetchNextFilesPage,
hasNextPage: hasNextPageFiles,
isFetchingNextPage: isFetchingNextFilesPage,
isLoading: isFilesLoading,
} = useInfiniteQuery<AssetInfoPaginatedList>({
queryKey: isRecentlyDeleted
? ['projects', projectId, 'recently-deleted', 'file']
@@ -305,6 +307,9 @@ export default function FileSystemManager({
const folders = foldersData?.pages.flatMap((page) => page.data ?? []) ?? []
const files = filesData?.pages.flatMap((page) => page.data ?? []) ?? []
const isFoldersQueryActive = !isFiltering && !isRecents
const isLoading = (isFoldersQueryActive ? isFoldersLoading : false) || isFilesLoading
const totalFolders = foldersData?.pages[0]?.pageInfo?.total
const totalFiles = filesData?.pages[0]?.pageInfo?.total
const totalFoldersSize = foldersData?.pages[0]?.pageInfo?.totalSize
@@ -449,6 +454,7 @@ export default function FileSystemManager({
isFetchingNextFilesPage={isFetchingNextFilesPage}
isRecentlyDeleted={isRecentlyDeleted}
isRecents={isRecents}
isLoading={isLoading}
rootFolderId={rootFolderId}
/>
)
@@ -544,6 +550,7 @@ export default function FileSystemManager({
isFetchingNextFilesPage={isFetchingNextFilesPage}
isRecentlyDeleted={isRecentlyDeleted}
isRecents={isRecents}
isLoading={isLoading}
filterConditions={filterConditions}
onFilterChange={setFilterConditions}
sort={sort}
@@ -1,4 +1,4 @@
import type { AssetInfo, AttachmentInfo, CommentInfo, FieldValueInfo } from '@shumai/dtos'
import type { AssetInfo, CommentInfo, FieldValueInfo } from '@shumai/dtos'
import { type FieldInfo as MetadataFieldInfo } from '@shumai/dtos'
import type { MemberInfo } from '@/ui/stores/members'
import { client } from '@/ui/api/client'
@@ -7,7 +7,6 @@ import { Tabs, TabsContent, TabsList, TabsTrigger } from '@/ui/components/ui/tab
import { useFieldStore } from '@/ui/stores/fields'
import type { Annotation } from '@/ui/types'
import { useInfiniteQuery, useMutation, useQuery, useQueryClient } from '@tanstack/react-query'
import { XIcon } from 'lucide-react'
import React, { useEffect, useMemo, useState } from 'react'
import { useInView } from 'react-intersection-observer'
import { MessageCard } from './chat/message-card'
@@ -56,7 +55,6 @@ export function FileViewerRightSidebar({
const queryClient = useQueryClient()
const { ref, inView } = useInView()
const [replyingTo, setReplyingTo] = useState<CommentInfo | null>(null)
const [viewingAttachment, setViewingAttachment] = useState<AttachmentInfo | null>(null)
const [isGuestPopupOpen, setIsGuestPopupOpen] = useState(false)
const [pendingComment, setPendingComment] = useState<{
text: string
@@ -290,26 +288,6 @@ export function FileViewerRightSidebar({
return (
<div className="bg-background h-full flex flex-col overflow-hidden">
{/* Lightbox */}
{viewingAttachment && viewingAttachment.proxyType === 'image' && (
<div
className="fixed inset-0 z-[100] bg-black/95 flex flex-col items-center justify-center p-4 animate-in fade-in duration-200"
onClick={() => setViewingAttachment(null)}
>
<button className="absolute top-4 right-4 text-white/70 hover:text-white bg-white/10 hover:bg-white/20 rounded-full p-2 transition-colors z-50">
<XIcon className="w-8 h-8" />
</button>
<div className="w-full h-full flex items-center justify-center p-2">
<img
src={viewingAttachment.url}
alt="Enlarged view"
className="max-w-full max-h-[85vh] object-contain rounded shadow-2xl cursor-zoom-out"
onClick={() => setViewingAttachment(null)}
/>
</div>
</div>
)}
<Tabs defaultValue="comments" className="p-1 flex-1 flex flex-col px-2 min-h-0">
<TabsList className="w-full shrink-0">
<TabsTrigger value="comments" className="flex-1">
@@ -329,7 +307,6 @@ export function FileViewerRightSidebar({
message={comment}
getUser={getUser}
onReply={setReplyingTo}
onViewAttachment={setViewingAttachment}
hasReplies={!!comment.replies?.length}
formatTimestamp={viewerDef?.commentsConfig?.formatTimestamp}
frameRate={
@@ -355,7 +332,6 @@ export function FileViewerRightSidebar({
message={reply}
getUser={getUser}
onReply={setReplyingTo}
onViewAttachment={setViewingAttachment}
hasReplies={false}
isLastReply={index === (comment.replies?.length ?? 0) - 1}
formatTimestamp={viewerDef?.commentsConfig?.formatTimestamp}
@@ -12,10 +12,9 @@ import { m } from '@/ui/paraglide/messages.js'
import { useFieldStore } from '@/ui/stores/fields'
import type { MemberInfo } from '@/ui/stores/members'
import type { Annotation } from '@/ui/types'
import type { AssetInfo, AttachmentInfo, CommentInfo, FieldValueInfo } from '@shumai/dtos'
import type { AssetInfo, CommentInfo, FieldValueInfo } from '@shumai/dtos'
import { type FieldInfo as MetadataFieldInfo } from '@shumai/dtos'
import { useInfiniteQuery, useMutation, useQuery, useQueryClient } from '@tanstack/react-query'
import { XIcon } from 'lucide-react'
import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react'
import { useInView } from 'react-intersection-observer'
import { toast } from 'sonner'
@@ -62,7 +61,6 @@ export function MobileFileBottomSheet({
const queryClient = useQueryClient()
const { ref, inView } = useInView()
const [replyingTo, setReplyingTo] = useState<CommentInfo | null>(null)
const [viewingAttachment, setViewingAttachment] = useState<AttachmentInfo | null>(null)
const [isGuestPopupOpen, setIsGuestPopupOpen] = useState(false)
const [pendingComment, setPendingComment] = useState<{
text: string
@@ -326,30 +324,6 @@ export function MobileFileBottomSheet({
className="shrink-0 flex flex-col bg-background border-t border-border shadow-2xl rounded-t-2xl overflow-hidden select-none z-20"
data-testid="mobile-bottom-sheet"
>
{/* Lightbox for attachment viewing */}
{viewingAttachment && viewingAttachment.proxyType === 'image' && (
<div
className="fixed inset-0 z-[100] bg-black/95 flex flex-col items-center justify-center p-4 animate-in fade-in duration-200"
onClick={() => setViewingAttachment(null)}
>
<button
className="absolute top-4 right-4 text-white/70 hover:text-white bg-white/10 hover:bg-white/20 rounded-full p-2 transition-colors z-50"
aria-label={m.close()}
>
<XIcon className="w-8 h-8" />
</button>
<div className="w-full h-full flex items-center justify-center p-2">
<img
src={viewingAttachment.url}
alt={m.preview()}
className="max-w-full max-h-[85vh] object-contain rounded shadow-2xl cursor-zoom-out"
onClick={() => setViewingAttachment(null)}
/>
</div>
</div>
)}
{/* Drag Handle Bar */}
<div
onPointerDown={handlePointerDown}
@@ -405,7 +379,6 @@ export function MobileFileBottomSheet({
message={comment}
getUser={getUser}
onReply={setReplyingTo}
onViewAttachment={setViewingAttachment}
hasReplies={!!comment.replies?.length}
formatTimestamp={viewerDef?.commentsConfig?.formatTimestamp}
frameRate={
@@ -431,7 +404,6 @@ export function MobileFileBottomSheet({
message={reply}
getUser={getUser}
onReply={setReplyingTo}
onViewAttachment={setViewingAttachment}
hasReplies={false}
isLastReply={index === (comment.replies?.length ?? 0) - 1}
formatTimestamp={viewerDef?.commentsConfig?.formatTimestamp}
@@ -24,8 +24,10 @@ import {
AlertDialogHeader,
AlertDialogTitle,
} from '@/ui/components/ui/alert-dialog'
import { Dialog, DialogContent, DialogHeader, DialogTitle } from '@/ui/components/ui/dialog'
import { formatSize } from '@/ui/lib/format'
import type { KanbanAttachmentInfo, KanbanCommentInfo } from '@shumai/dtos'
import { isImageFileName } from '@/ui/lib/media'
import type { KanbanCommentInfo } from '@shumai/dtos'
interface TaskCommentCardProps {
teamId: string
@@ -33,7 +35,6 @@ interface TaskCommentCardProps {
comment: KanbanCommentInfo
currentUserId?: string
isOwnerOrAdmin?: boolean
onViewAttachment?: (attachment: KanbanAttachmentInfo) => void
}
export function TaskCommentCard({
@@ -42,10 +43,10 @@ export function TaskCommentCard({
comment,
currentUserId,
isOwnerOrAdmin,
onViewAttachment,
}: TaskCommentCardProps) {
const queryClient = useQueryClient()
const [isDeleteDialogOpen, setIsDeleteDialogOpen] = useState(false)
const [previewImage, setPreviewImage] = useState<{ url: string; name: string } | null>(null)
const canDelete = isOwnerOrAdmin || comment.author.id === currentUserId
@@ -88,7 +89,7 @@ export function TaskCommentCard({
.toUpperCase()
return (
<div className="relative flex gap-3 p-3 rounded-xl border border-transparent bg-foreground/[0.03] dark:bg-foreground/[0.08] hover:bg-foreground/[0.06] dark:hover:bg-foreground/[0.12] transition-colors group">
<div className="relative flex gap-3 p-3 rounded-xl border border-transparent bg-foreground/[0.03] dark:bg-foreground/[0.08] hover:bg-foreground/[0.06] dark:hover:bg-foreground/[0.12] transition-colors group w-full max-w-full overflow-hidden">
{/* Left Avatar */}
<Avatar className="w-7 h-7 shrink-0 mt-0.5 border border-border">
{comment.author.image && (
@@ -100,7 +101,7 @@ export function TaskCommentCard({
</Avatar>
{/* Main Content Area */}
<div className="flex-1 min-w-0 space-y-1.5">
<div className="flex-1 min-w-0 space-y-1.5 overflow-hidden">
{/* Header: Author + Timestamp + Actions */}
<div className="flex items-center justify-between gap-2">
<div className="flex items-center gap-2 min-w-0">
@@ -143,62 +144,60 @@ export function TaskCommentCard({
{/* Attachments Section */}
{comment.attachments && comment.attachments.length > 0 && (
<div className="flex flex-wrap gap-2 pt-1.5">
<div className="flex flex-col gap-1.5 pt-1.5 w-full max-w-full overflow-hidden">
{comment.attachments.map((att) => {
const isImage = att.proxyType === 'image' || att.contentType?.startsWith('image/')
const isImage = isImageFileName(att.name || att.url)
return (
<div
key={att.id}
className="relative group/att rounded-lg border border-border bg-card overflow-hidden transition-all duration-200"
className={`group/att relative flex items-center w-full max-w-full rounded-lg border border-border bg-card hover:bg-muted/40 transition-colors overflow-hidden ${
isImage ? 'h-18 p-1.5 gap-2.5 cursor-pointer' : 'h-9 px-2.5 gap-2.5'
}`}
onClick={() => {
if (isImage) {
setPreviewImage({ url: att.url, name: att.name })
} else {
window.open(att.url, '_blank', 'noreferrer')
}
}}
>
{isImage ? (
<div
className="w-40 h-28 relative cursor-pointer overflow-hidden bg-muted/40"
onClick={() => onViewAttachment?.(att)}
>
<div className="h-full aspect-square rounded-md overflow-hidden bg-muted/40 shrink-0">
<img
src={att.url}
alt={att.name}
className="w-full h-full object-cover group-hover/att:scale-105 transition-transform duration-200"
/>
<a
href={att.url}
download={att.name}
target="_blank"
rel="noreferrer"
className="absolute right-1.5 bottom-1.5 bg-black/60 hover:bg-black/80 text-white p-1 rounded-md opacity-0 group-hover/att:opacity-100 transition-opacity shadow-xs"
onClick={(e) => e.stopPropagation()}
title="Download"
>
<Download className="w-3.5 h-3.5" />
</a>
</div>
) : (
<div className="flex items-center gap-2.5 p-2.5 max-w-[240px] bg-card hover:bg-muted/40 transition-colors">
<FileText className="w-7 h-7 text-primary/80 shrink-0" />
<div className="min-w-0 flex-1">
<p
className="text-xs font-medium text-foreground truncate"
title={att.name}
>
{att.name}
</p>
<p className="text-[10px] text-muted-foreground font-mono">
{formatSize(att.sizeByte)}
</p>
</div>
<a
href={att.url}
download={att.name}
target="_blank"
rel="noreferrer"
className="p-1 text-muted-foreground hover:text-foreground shrink-0 rounded-md hover:bg-muted transition-colors"
title="Download"
>
<Download className="w-3.5 h-3.5" />
</a>
</div>
<FileText className="w-4 h-4 text-muted-foreground shrink-0" />
)}
<div className="min-w-0 flex-1 overflow-hidden">
<p
className="text-xs font-medium text-foreground truncate block w-full"
title={att.name}
>
{att.name}
</p>
{att.sizeByte !== undefined && att.sizeByte > 0 && (
<p className="text-[10px] text-muted-foreground font-mono truncate">
{formatSize(att.sizeByte)}
</p>
)}
</div>
<a
href={att.url}
download={att.name}
target="_blank"
rel="noreferrer"
className="p-1 text-muted-foreground hover:text-foreground shrink-0 rounded-md hover:bg-muted transition-colors opacity-0 group-hover/att:opacity-100"
onClick={(e) => e.stopPropagation()}
title={m.download()}
>
<Download className="w-3.5 h-3.5" />
</a>
</div>
)
})}
@@ -225,6 +224,30 @@ export function TaskCommentCard({
</AlertDialogFooter>
</AlertDialogContent>
</AlertDialog>
{/* Image Preview Dialog */}
<Dialog open={!!previewImage} onOpenChange={(open) => !open && setPreviewImage(null)}>
<DialogContent
className="w-auto max-w-[80vw] sm:max-w-[80vw] max-h-[80vh] p-2 sm:p-3 bg-background/95 backdrop-blur-sm border-border flex flex-col items-center justify-center overflow-hidden"
onClick={(e) => e.stopPropagation()}
>
<DialogHeader className="sr-only">
<DialogTitle>{previewImage?.name || 'Image Preview'}</DialogTitle>
</DialogHeader>
{previewImage && (
<div className="flex flex-col items-center justify-center max-w-[80vw] max-h-[80vh] overflow-hidden">
<img
src={previewImage.url}
alt={previewImage.name}
className="max-w-[80vw] max-h-[calc(80vh-2.5rem)] w-auto h-auto object-contain rounded-md"
/>
<p className="text-xs text-muted-foreground truncate max-w-full px-2 pt-1.5 text-center">
{previewImage.name}
</p>
</div>
)}
</DialogContent>
</Dialog>
</div>
)
}
@@ -1,13 +1,12 @@
import { useState } from 'react'
import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query'
import { client } from '@/ui/api/client'
import { m } from '@/ui/paraglide/messages.js'
import { ScrollArea } from '@/ui/components/ui/scroll-area'
import { toast } from 'sonner'
import { Loader2, MessageSquare, X } from 'lucide-react'
import { Loader2, MessageSquare } from 'lucide-react'
import { TaskCommentCard } from './task-comment-card'
import { TaskCommentInput } from './task-comment-input'
import type { KanbanAttachmentInfo, KanbanAttachmentPayload, KanbanCommentInfo } from '@shumai/dtos'
import type { KanbanAttachmentPayload, KanbanCommentInfo } from '@shumai/dtos'
interface TaskCommentThreadProps {
teamId: string
@@ -17,7 +16,6 @@ interface TaskCommentThreadProps {
export function TaskCommentThread({ teamId, taskId, initialComments }: TaskCommentThreadProps) {
const queryClient = useQueryClient()
const [viewingAttachment, setViewingAttachment] = useState<KanbanAttachmentInfo | null>(null)
// Query Current User Info
const { data: me } = useQuery({
@@ -92,35 +90,9 @@ export function TaskCommentThread({ teamId, taskId, initialComments }: TaskComme
return (
<div className="flex flex-col h-full overflow-hidden bg-background">
{/* Lightbox / Full-screen Attachment Viewer */}
{viewingAttachment && (
<div
className="fixed inset-0 z-50 bg-black/90 flex flex-col items-center justify-center p-4 animate-in fade-in duration-150"
onClick={() => setViewingAttachment(null)}
>
<button
type="button"
onClick={() => setViewingAttachment(null)}
className="absolute top-4 right-4 text-white/80 hover:text-white bg-white/10 hover:bg-white/20 rounded-full p-2 transition-colors z-50 cursor-pointer"
title="Close"
>
<X className="w-6 h-6" />
</button>
<div className="w-full h-full flex items-center justify-center p-2">
<img
src={viewingAttachment.url}
alt={viewingAttachment.name}
className="max-w-full max-h-[85vh] object-contain rounded-lg shadow-2xl"
onClick={(e) => e.stopPropagation()}
/>
</div>
</div>
)}
{/* Comments List */}
<ScrollArea className="flex-1 p-3.5">
<div className="space-y-3 pr-1 pb-2">
<ScrollArea className="flex-1 min-h-0 p-3.5 [&>div>div]:block!">
<div className="space-y-3 pr-1 pb-2 w-full max-w-full">
{isLoading ? (
<div className="flex items-center justify-center py-12">
<Loader2 className="w-6 h-6 animate-spin text-muted-foreground" />
@@ -141,7 +113,6 @@ export function TaskCommentThread({ teamId, taskId, initialComments }: TaskComme
comment={comment}
currentUserId={me?.id}
isOwnerOrAdmin={isOwnerOrAdmin}
onViewAttachment={(att) => setViewingAttachment(att)}
/>
))
)}
@@ -449,7 +449,6 @@ describe('Kanban UI Unit & Component Tests', () => {
updatedAt: '2026-08-20T00:00:00.000Z',
}
const onViewAttachment = vi.fn()
render(
<TaskCommentCard
teamId="team-1"
@@ -457,19 +456,37 @@ describe('Kanban UI Unit & Component Tests', () => {
comment={mockComment}
currentUserId="u-1"
isOwnerOrAdmin={true}
onViewAttachment={onViewAttachment}
/>,
{ wrapper: createWrapper() },
)
expect(screen.getByText('Alice Author')).toBeDefined()
expect(screen.getByText('bold')).toBeDefined()
expect(screen.getByText('preview.png')).toBeDefined()
expect(screen.getByText('specs.pdf')).toBeDefined()
// Click image attachment
const img = screen.getByAltText('preview.png')
fireEvent.click(img)
expect(onViewAttachment).toHaveBeenCalledWith(mockComment.attachments[0])
// Verify row classes for 2x image height (h-18) vs standard file height (h-9)
const previewImg = screen.getByAltText('preview.png')
const imageRow = previewImg.closest('.group\\/att')
expect(imageRow?.className).toContain('h-18')
const pdfText = screen.getByText('specs.pdf')
const pdfRow = pdfText.closest('.group\\/att')
expect(pdfRow?.className).toContain('h-9')
// Click image attachment row opens preview dialog
fireEvent.click(imageRow!)
expect(screen.getAllByAltText('preview.png').length).toBeGreaterThanOrEqual(2)
// Click PDF attachment row
const windowOpenSpy = vi.spyOn(window, 'open').mockImplementation(() => null)
fireEvent.click(pdfRow!)
expect(windowOpenSpy).toHaveBeenCalledWith(
'https://example.com/specs.pdf',
'_blank',
'noreferrer',
)
windowOpenSpy.mockRestore()
})
it('renders TaskCommentInput and triggers send on button click', async () => {
@@ -167,3 +167,65 @@ export function FileDetailSkeleton() {
</div>
)
}
export function FileBrowserContentSkeleton({
displayStyle = 'card',
}: {
displayStyle?: 'card' | 'list'
}) {
if (displayStyle === 'list') {
return (
<div className="p-4 space-y-2" data-testid="file-browser-loading-skeleton">
{Array.from({ length: 8 }).map((_, i) => (
<div key={i} className="flex items-center gap-4 py-2 border-b border-border/40">
<Skeleton className="h-4 w-4 rounded" />
<Skeleton className="h-4 w-4 rounded" />
<Skeleton className="h-4 w-48" />
<div className="ml-auto flex items-center gap-8">
<Skeleton className="h-3 w-16" />
<Skeleton className="h-3 w-24" />
</div>
</div>
))}
</div>
)
}
return (
<div className="p-4 space-y-4" data-testid="file-browser-loading-skeleton">
<div className="grid grid-cols-1 gap-4 sm:grid-cols-2 md:grid-cols-3 lg:grid-cols-4 xl:grid-cols-5">
{Array.from({ length: 10 }).map((_, i) => (
<div key={i} className="flex flex-col rounded-lg border bg-card p-3 space-y-3">
<Skeleton className="aspect-square w-full rounded-md" />
<div className="space-y-2">
<Skeleton className="h-4 w-3/4" />
<div className="flex justify-between items-center">
<Skeleton className="h-3 w-1/4" />
<Skeleton className="h-3 w-1/3" />
</div>
</div>
</div>
))}
</div>
</div>
)
}
export function MobileFileBrowserContentSkeleton() {
return (
<div
className="p-3 space-y-3 max-w-lg mx-auto w-full"
data-testid="mobile-file-browser-loading-skeleton"
>
{Array.from({ length: 6 }).map((_, i) => (
<div key={i} className="flex items-center gap-3 p-3 rounded-lg border bg-card">
<Skeleton className="h-10 w-10 rounded-md shrink-0" />
<div className="space-y-2 flex-1">
<Skeleton className="h-4 w-3/4" />
<Skeleton className="h-3 w-1/3" />
</div>
</div>
))}
</div>
)
}
@@ -191,6 +191,9 @@ export function ManageVersionsDialog({
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ['version_stacks'] })
queryClient.invalidateQueries({ queryKey: ['files'] })
queryClient.invalidateQueries({ queryKey: ['file'] })
queryClient.invalidateQueries({ queryKey: ['search'] })
queryClient.invalidateQueries({ queryKey: ['folders'] })
queryClient.invalidateQueries({ queryKey: ['projects'] })
toast.success(m.version_reordered_successfully())
},
@@ -218,6 +221,9 @@ export function ManageVersionsDialog({
queryClient.invalidateQueries({ queryKey: ['version_stacks'] })
queryClient.invalidateQueries({ queryKey: ['files'] })
queryClient.invalidateQueries({ queryKey: ['file'] })
queryClient.invalidateQueries({ queryKey: ['search'] })
queryClient.invalidateQueries({ queryKey: ['folders'] })
queryClient.invalidateQueries({ queryKey: ['projects'] })
if (remaining.length <= 1) {
@@ -160,6 +160,7 @@ export function PublicShareManager({
fetchNextPage: fetchNextFoldersPage,
hasNextPage: hasNextPageFolders,
isFetchingNextPage: isFetchingNextFoldersPage,
isLoading: isFoldersLoading,
error: foldersError,
} = useInfiniteQuery<AssetInfoPaginatedList>({
queryKey: ['public-share-children', shareId, currentFolderId, 'folder', password],
@@ -193,6 +194,7 @@ export function PublicShareManager({
fetchNextPage: fetchNextFilesPage,
hasNextPage: hasNextPageFiles,
isFetchingNextPage: isFetchingNextFilesPage,
isLoading: isFilesLoading,
} = useInfiniteQuery<AssetInfoPaginatedList>({
queryKey: ['public-share-children', shareId, currentFolderId, 'file', password],
queryFn: async ({ pageParam }) => {
@@ -691,6 +693,7 @@ export function PublicShareManager({
fetchNextFilesPage={fetchNextFilesPage}
hasNextFilesPage={hasNextPageFiles}
isFetchingNextFilesPage={isFetchingNextFilesPage}
isLoading={isFoldersLoading || isFilesLoading}
isShareView={true}
isPublic={true}
shareId={shareId}
@@ -725,6 +728,7 @@ export function PublicShareManager({
fetchNextFilesPage={fetchNextFilesPage}
hasNextFilesPage={hasNextPageFiles}
isFetchingNextFilesPage={isFetchingNextFilesPage}
isLoading={isFoldersLoading || isFilesLoading}
isShareView={true}
isPublic={true}
shareId={shareId}
@@ -112,6 +112,7 @@ export default function ShareManager({
fetchNextPage: fetchNextFoldersPage,
hasNextPage: hasNextPageFolders,
isFetchingNextPage: isFetchingNextFoldersPage,
isLoading: isFoldersLoading,
} = useInfiniteQuery<AssetInfoPaginatedList>({
queryKey: ['folder-children', teamId, currentFolderId, 'folder', sort, order],
queryFn: async ({ pageParam }) => {
@@ -137,6 +138,7 @@ export default function ShareManager({
fetchNextPage: fetchNextFilesPage,
hasNextPage: hasNextPageFiles,
isFetchingNextPage: isFetchingNextFilesPage,
isLoading: isFilesLoading,
} = useInfiniteQuery<AssetInfoPaginatedList>({
queryKey: ['folder-children', teamId, currentFolderId, 'file', sort, order],
queryFn: async ({ pageParam }) => {
@@ -321,6 +323,7 @@ export default function ShareManager({
fetchNextFilesPage={fetchNextFilesPage}
hasNextFilesPage={hasNextPageFiles}
isFetchingNextFilesPage={isFetchingNextFilesPage}
isLoading={isFoldersLoading || isFilesLoading}
filterConditions={[]}
onFilterChange={() => {}}
dragState={dragState}
@@ -0,0 +1,602 @@
// @vitest-environment happy-dom
import { renderHook, act } from '@testing-library/react'
import { describe, expect, it, vi, beforeEach } from 'vitest'
import { useFileSystemDnd } from './use-file-system-dnd'
import type { AssetInfo } from '@shumai/dtos'
import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
import React from 'react'
const mockReparent = vi.fn().mockResolvedValue({ ok: true })
const mockReorderFolder = vi.fn().mockResolvedValue({ ok: true, json: async () => ({}) })
const mockReorderFile = vi.fn().mockResolvedValue({ ok: true, json: async () => ({}) })
const mockAddAssetToShare = vi
.fn()
.mockResolvedValue({ ok: true, json: async () => ({ addedCount: 1 }) })
vi.mock('@/ui/api/client', () => ({
client: {
api: {
projects: {
':projectId': {
reparent: {
$post: (...args: unknown[]) => mockReparent(...args),
},
},
},
folders: {
':folderId': {
order: {
$patch: (...args: unknown[]) => mockReorderFolder(...args),
},
},
},
files: {
':fileId': {
order: {
$patch: (...args: unknown[]) => mockReorderFile(...args),
},
},
},
shares: {
':shareId': {
assets: {
$post: (...args: unknown[]) => mockAddAssetToShare(...args),
},
},
},
},
},
}))
describe('useFileSystemDnd', () => {
let queryClient: QueryClient
beforeEach(() => {
queryClient = new QueryClient({
defaultOptions: { queries: { retry: false }, mutations: { retry: false } },
})
vi.clearAllMocks()
})
const folders: AssetInfo[] = [
{ id: 'folder-1', name: 'Folder 1', type: 'folder', status: 'processed' } as AssetInfo,
]
const files: AssetInfo[] = [
{ id: 'file-1', name: 'File 1.png', type: 'file', status: 'processed' } as AssetInfo,
{ id: 'file-2', name: 'File 2.png', type: 'file', status: 'processed' } as AssetInfo,
{ id: 'stack-1', name: 'Stack 1', type: 'version_stack', status: 'processed' } as AssetInfo,
{ id: 'stack-2', name: 'Stack 2', type: 'version_stack', status: 'processed' } as AssetInfo,
]
const wrapper = ({ children }: { children: React.ReactNode }) => (
<QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
)
describe('handleDragStart dragState computation', () => {
it('sets isSingleFile true when dragging a single regular file', () => {
const { result } = renderHook(
() =>
useFileSystemDnd({
teamId: 'team-1',
projectId: 'proj-1',
assetId: 'asset-1',
folders,
files,
selectedIds: new Set(),
onClearSelection: vi.fn(),
}),
{ wrapper },
)
act(() => {
result.current.handleDragStart({
operation: {
source: {
id: 'browser:file-1',
data: { type: 'file', item: files[0] },
},
},
} as never)
})
expect(result.current.dragState).toEqual({
isActive: true,
draggedIds: new Set(['file-1']),
hasFolders: false,
isSingleFile: true,
itemCount: 1,
})
})
it('sets isSingleFile false when dragging a version stack', () => {
const { result } = renderHook(
() =>
useFileSystemDnd({
teamId: 'team-1',
projectId: 'proj-1',
assetId: 'asset-1',
folders,
files,
selectedIds: new Set(),
onClearSelection: vi.fn(),
}),
{ wrapper },
)
act(() => {
result.current.handleDragStart({
operation: {
source: {
id: 'browser:stack-1',
data: { type: 'version_stack', item: files[2] },
},
},
} as never)
})
expect(result.current.dragState).toEqual({
isActive: true,
draggedIds: new Set(['stack-1']),
hasFolders: false,
isSingleFile: false,
itemCount: 1,
})
})
it('sets hasFolders true when dragging a folder', () => {
const { result } = renderHook(
() =>
useFileSystemDnd({
teamId: 'team-1',
projectId: 'proj-1',
assetId: 'asset-1',
folders,
files,
selectedIds: new Set(),
onClearSelection: vi.fn(),
}),
{ wrapper },
)
act(() => {
result.current.handleDragStart({
operation: {
source: {
id: 'browser:folder-1',
data: { type: 'folder', item: folders[0] },
},
},
} as never)
})
expect(result.current.dragState).toEqual({
isActive: true,
draggedIds: new Set(['folder-1']),
hasFolders: true,
isSingleFile: false,
itemCount: 1,
})
})
it('sets isSingleFile false when dragging multiple selected files', () => {
const selectedIds = new Set(['file-1', 'file-2'])
const { result } = renderHook(
() =>
useFileSystemDnd({
teamId: 'team-1',
projectId: 'proj-1',
assetId: 'asset-1',
folders,
files,
selectedIds,
onClearSelection: vi.fn(),
}),
{ wrapper },
)
act(() => {
result.current.handleDragStart({
operation: {
source: {
id: 'browser:file-1',
data: { type: 'file', item: files[0] },
},
},
} as never)
})
expect(result.current.dragState).toEqual({
isActive: true,
draggedIds: new Set(['file-1', 'file-2']),
hasFolders: false,
isSingleFile: false,
itemCount: 2,
})
})
it('sets isSingleFile false when draggedIds contains unloaded items outside visible items', () => {
const selectedIds = new Set(['file-1', 'file-unloaded'])
const { result } = renderHook(
() =>
useFileSystemDnd({
teamId: 'team-1',
projectId: 'proj-1',
assetId: 'asset-1',
folders,
files,
selectedIds,
onClearSelection: vi.fn(),
}),
{ wrapper },
)
act(() => {
result.current.handleDragStart({
operation: {
source: {
id: 'browser:file-1',
data: { type: 'file', item: files[0] },
},
},
} as never)
})
expect(result.current.dragState).toEqual({
isActive: true,
draggedIds: new Set(['file-1', 'file-unloaded']),
hasFolders: false,
isSingleFile: false,
itemCount: 2,
})
})
})
describe('handleDragEnd drop execution', () => {
it('executes reparentAssets when dropping a single file onto another file', async () => {
const onClearSelection = vi.fn()
const { result } = renderHook(
() =>
useFileSystemDnd({
teamId: 'team-1',
projectId: 'proj-1',
assetId: 'asset-1',
folders,
files,
selectedIds: new Set(),
onClearSelection,
}),
{ wrapper },
)
act(() => {
result.current.handleDragStart({
operation: {
source: {
id: 'browser:file-1',
data: { type: 'file', item: files[0] },
},
},
} as never)
})
act(() => {
result.current.handleDragEnd({
operation: {
target: {
id: 'browser:file-2',
data: { type: 'file', item: files[1] },
},
},
} as never)
})
await vi.waitFor(() => {
expect(mockReparent).toHaveBeenCalledWith({
param: { projectId: 'proj-1' },
json: {
assetIds: ['file-1'],
newParentId: 'file-2',
},
})
})
})
it('executes reparentAssets when dropping a single file onto a version stack', async () => {
const { result } = renderHook(
() =>
useFileSystemDnd({
teamId: 'team-1',
projectId: 'proj-1',
assetId: 'asset-1',
folders,
files,
selectedIds: new Set(),
onClearSelection: vi.fn(),
}),
{ wrapper },
)
act(() => {
result.current.handleDragStart({
operation: {
source: {
id: 'browser:file-1',
data: { type: 'file', item: files[0] },
},
},
} as never)
})
act(() => {
result.current.handleDragEnd({
operation: {
target: {
id: 'browser:stack-1',
data: { type: 'version_stack', item: files[2] },
},
},
} as never)
})
await vi.waitFor(() => {
expect(mockReparent).toHaveBeenCalledWith({
param: { projectId: 'proj-1' },
json: {
assetIds: ['file-1'],
newParentId: 'stack-1',
},
})
})
})
it('does NOT execute reparentAssets when dropping a version stack onto a file', () => {
const { result } = renderHook(
() =>
useFileSystemDnd({
teamId: 'team-1',
projectId: 'proj-1',
assetId: 'asset-1',
folders,
files,
selectedIds: new Set(),
onClearSelection: vi.fn(),
}),
{ wrapper },
)
act(() => {
result.current.handleDragStart({
operation: {
source: {
id: 'browser:stack-1',
data: { type: 'version_stack', item: files[2] },
},
},
} as never)
})
act(() => {
result.current.handleDragEnd({
operation: {
target: {
id: 'browser:file-1',
data: { type: 'file', item: files[0] },
},
},
} as never)
})
expect(mockReparent).not.toHaveBeenCalled()
})
it('does NOT execute reparentAssets when dropping a version stack onto another version stack', () => {
const { result } = renderHook(
() =>
useFileSystemDnd({
teamId: 'team-1',
projectId: 'proj-1',
assetId: 'asset-1',
folders,
files,
selectedIds: new Set(),
onClearSelection: vi.fn(),
}),
{ wrapper },
)
act(() => {
result.current.handleDragStart({
operation: {
source: {
id: 'browser:stack-1',
data: { type: 'version_stack', item: files[2] },
},
},
} as never)
})
act(() => {
result.current.handleDragEnd({
operation: {
target: {
id: 'browser:stack-2',
data: { type: 'version_stack', item: files[3] },
},
},
} as never)
})
expect(mockReparent).not.toHaveBeenCalled()
})
it('executes reparentAssets when dropping a version stack onto a folder', async () => {
const { result } = renderHook(
() =>
useFileSystemDnd({
teamId: 'team-1',
projectId: 'proj-1',
assetId: 'asset-1',
folders,
files,
selectedIds: new Set(),
onClearSelection: vi.fn(),
}),
{ wrapper },
)
act(() => {
result.current.handleDragStart({
operation: {
source: {
id: 'browser:stack-1',
data: { type: 'version_stack', item: files[2] },
},
},
} as never)
})
act(() => {
result.current.handleDragEnd({
operation: {
target: {
id: 'browser:folder-1',
data: { type: 'folder', item: folders[0] },
},
},
} as never)
})
await vi.waitFor(() => {
expect(mockReparent).toHaveBeenCalledWith({
param: { projectId: 'proj-1' },
json: {
assetIds: ['stack-1'],
newParentId: 'folder-1',
},
})
})
})
it('does NOT execute reparentAssets when dropping a folder onto a version stack or file', () => {
const { result } = renderHook(
() =>
useFileSystemDnd({
teamId: 'team-1',
projectId: 'proj-1',
assetId: 'asset-1',
folders,
files,
selectedIds: new Set(),
onClearSelection: vi.fn(),
}),
{ wrapper },
)
act(() => {
result.current.handleDragStart({
operation: {
source: {
id: 'browser:folder-1',
data: { type: 'folder', item: folders[0] },
},
},
} as never)
})
act(() => {
result.current.handleDragEnd({
operation: {
target: {
id: 'browser:stack-1',
data: { type: 'version_stack', item: files[2] },
},
},
} as never)
})
expect(mockReparent).not.toHaveBeenCalled()
})
it('does NOT execute reparentAssets when dropping multiple files onto a version stack or file', () => {
const selectedIds = new Set(['file-1', 'file-2'])
const { result } = renderHook(
() =>
useFileSystemDnd({
teamId: 'team-1',
projectId: 'proj-1',
assetId: 'asset-1',
folders,
files,
selectedIds,
onClearSelection: vi.fn(),
}),
{ wrapper },
)
act(() => {
result.current.handleDragStart({
operation: {
source: {
id: 'browser:file-1',
data: { type: 'file', item: files[0] },
},
},
} as never)
})
act(() => {
result.current.handleDragEnd({
operation: {
target: {
id: 'browser:stack-1',
data: { type: 'version_stack', item: files[2] },
},
},
} as never)
})
expect(mockReparent).not.toHaveBeenCalled()
})
it('does NOT execute reparentAssets when dragging selection with unloaded items onto a file or version stack', () => {
const selectedIds = new Set(['file-1', 'file-unloaded'])
const { result } = renderHook(
() =>
useFileSystemDnd({
teamId: 'team-1',
projectId: 'proj-1',
assetId: 'asset-1',
folders,
files,
selectedIds,
onClearSelection: vi.fn(),
}),
{ wrapper },
)
act(() => {
result.current.handleDragStart({
operation: {
source: {
id: 'browser:file-1',
data: { type: 'file', item: files[0] },
},
},
} as never)
})
act(() => {
result.current.handleDragEnd({
operation: {
target: {
id: 'browser:stack-1',
data: { type: 'version_stack', item: files[2] },
},
},
} as never)
})
expect(mockReparent).not.toHaveBeenCalled()
})
})
})
@@ -173,11 +173,14 @@ export function useFileSystemDnd({
}
const hasFolders = draggedItems.some((item) => item.type === 'folder')
const isSingleFile =
draggedIds.size === 1 && draggedItems.length === 1 && draggedItems[0].type === 'file'
setDragState({
isActive: true,
draggedIds,
hasFolders,
isSingleFile,
itemCount: draggedIds.size,
})
}
@@ -242,9 +245,9 @@ export function useFileSystemDnd({
if (targetData && !dragState.draggedIds.has(targetId)) {
if (targetData.type === 'folder' || targetData.type === 'reorder') {
isValid = true
} else if (targetData.type === 'file') {
// Can only drop single file onto single file
if (!dragState.hasFolders && dragState.itemCount === 1) {
} else if (targetData.type === 'file' || targetData.type === 'version_stack') {
// Can only drop single regular file onto file or version stack
if (dragState.isSingleFile) {
isValid = true
}
}
+51
View File
@@ -0,0 +1,51 @@
import { describe, it, expect } from 'vitest'
import { isImageFileName, getBestTranscode } from './media'
describe('isImageFileName', () => {
it('identifies web-supported image formats as images', () => {
expect(isImageFileName('photo.png')).toBe(true)
expect(isImageFileName('photo.jpg')).toBe(true)
expect(isImageFileName('photo.jpeg')).toBe(true)
expect(isImageFileName('photo.webp')).toBe(true)
expect(isImageFileName('animation.gif')).toBe(true)
expect(isImageFileName('icon.svg')).toBe(true)
expect(isImageFileName('image.avif')).toBe(true)
expect(isImageFileName('bitmap.bmp')).toBe(true)
expect(isImageFileName('favicon.ico')).toBe(true)
})
it('handles uppercase extensions and paths/urls with query params', () => {
expect(isImageFileName('PHOTO.PNG')).toBe(true)
expect(isImageFileName('PHOTO.JPEG')).toBe(true)
expect(isImageFileName('/path/to/my-image.webp')).toBe(true)
})
it('does not treat non-web-renderable or non-image files as images', () => {
expect(isImageFileName('design.psd')).toBe(false)
expect(isImageFileName('photo.raw')).toBe(false)
expect(isImageFileName('document.pdf')).toBe(false)
expect(isImageFileName('video.mp4')).toBe(false)
expect(isImageFileName('archive.zip')).toBe(false)
expect(isImageFileName('notes.txt')).toBe(false)
expect(isImageFileName('')).toBe(false)
expect(isImageFileName(null)).toBe(false)
expect(isImageFileName(undefined)).toBe(false)
})
})
describe('getBestTranscode', () => {
it('returns null if transcodes array is empty or undefined', () => {
expect(getBestTranscode(undefined, 800)).toBeNull()
expect(getBestTranscode([], 800)).toBeNull()
})
it('picks smallest transcode >= screenWidth or falls back to largest', () => {
const transcodes = [
{ id: '1', width: 400, height: 300, url: '', key: '', size: 100 },
{ id: '2', width: 800, height: 600, url: '', key: '', size: 200 },
{ id: '3', width: 1200, height: 900, url: '', key: '', size: 300 },
]
expect(getBestTranscode(transcodes, 700)?.width).toBe(800)
expect(getBestTranscode(transcodes, 1500)?.width).toBe(1200)
})
})
+7
View File
@@ -2,6 +2,13 @@ import type { ImageTranscode, VideoTranscode } from '@shumai/dtos'
type Transcode = ImageTranscode | VideoTranscode
const WEB_IMAGE_EXTENSION_REGEX = /\.(png|jpe?g|webp|gif|svg|avif|bmp|ico)$/i
export function isImageFileName(filename?: string | null): boolean {
if (!filename) return false
return WEB_IMAGE_EXTENSION_REGEX.test(filename)
}
export function getBestTranscode(
transcodes: Transcode[] | undefined,
screenWidth: number,
+2 -1
View File
@@ -1312,5 +1312,6 @@
"timecode": "Timecode",
"playback_speed": "Playback Speed",
"settings": "Settings",
"failed_to_post_comment": "Failed to post comment"
"failed_to_post_comment": "Failed to post comment",
"entry_id": "Entry ID"
}
+2 -1
View File
@@ -1312,5 +1312,6 @@
"timecode": "时间码",
"playback_speed": "播放速度",
"settings": "设置",
"failed_to_post_comment": "发送评论失败"
"failed_to_post_comment": "发送评论失败",
"entry_id": "条目 ID"
}
+1 -1
View File
@@ -1,6 +1,6 @@
{
"name": "@shumai/webui",
"version": "0.4.0",
"version": "0.4.1",
"private": true,
"type": "module",
"main": "./index.html",
+1
View File
@@ -1250,4 +1250,5 @@ export * from "./frames.js";
export * from "./timecode.js";
export * from "./playback_speed.js";
export * from "./failed_to_post_comment.js";
export * from "./entry_id.js";
export type LocalizedString = import("../runtime.js").LocalizedString;
+2 -1
View File
@@ -1251,4 +1251,5 @@ export * from './standard_time.js'
export * from './frames.js'
export * from './timecode.js'
export * from './playback_speed.js'
export * from './failed_to_post_comment.js'
export * from './failed_to_post_comment.js'
export * from './entry_id.js'
+16
View File
@@ -0,0 +1,16 @@
/**
* | output |
* | --- |
* | "Entry ID" |
*
* @param {Entry_IdInputs} inputs
* @param {{ locale?: "en" | "zh" }} options
* @returns {LocalizedString}
*/
export const entry_id: ((inputs?: Entry_IdInputs, options?: {
locale?: "en" | "zh";
}) => LocalizedString) & import("../runtime.js").MessageMetadata<Entry_IdInputs, {
locale?: "en" | "zh";
}, {}>;
export type LocalizedString = import("../runtime.js").LocalizedString;
export type Entry_IdInputs = {};
+29
View File
@@ -0,0 +1,29 @@
/* eslint-disable */
import { getLocale, experimentalStaticLocale } from '../runtime.js';
/** @typedef {import('../runtime.js').LocalizedString} LocalizedString */
/** @typedef {{}} Entry_IdInputs */
const en_entry_id = /** @type {(inputs: Entry_IdInputs) => LocalizedString} */ () => {
return /** @type {LocalizedString} */ (`Entry ID`)
};
const zh_entry_id = /** @type {(inputs: Entry_IdInputs) => LocalizedString} */ () => {
return /** @type {LocalizedString} */ (`条目 ID`)
};
/**
* | output |
* | --- |
* | "Entry ID" |
*
* @param {Entry_IdInputs} inputs
* @param {{ locale?: "en" | "zh" }} options
* @returns {LocalizedString}
*/
export const entry_id = /** @type {((inputs?: Entry_IdInputs, options?: { locale?: "en" | "zh" }) => LocalizedString) & import('../runtime.js').MessageMetadata<Entry_IdInputs, { locale?: "en" | "zh" }, {}>} */ ((inputs = {}, options = {}) => {
const locale = experimentalStaticLocale ?? options.locale ?? getLocale()
if (locale === "en") return en_entry_id(inputs)
return zh_entry_id(inputs)
});
+50
View File
@@ -368,4 +368,54 @@ describe('useChatbotStore', () => {
expect(onAssetMutation).toHaveBeenCalledTimes(1)
})
it('should replace optimistic message when shumai_message entry streams back', async () => {
const mockEvents = [
'data: {"type":"session","sessionId":"sess-123"}\n\n',
'data: {"type":"entry","entry":{"id":"user-msg-ulid","role":"custom","customType":"shumai_message","content":"hello","details":{"user":{"id":"u1","name":"User 1"}},"timestamp":123}}\n\n',
'data: {"type":"entry","entry":{"id":"assistant-msg-ulid","role":"assistant","content":[{"type":"text","text":"Hi!"}],"timestamp":124}}\n\n',
'data: {"type":"done","status":"completed"}\n\n',
]
let eventIdx = 0
const mockReader = {
read: vi.fn(async () => {
if (eventIdx < mockEvents.length) {
const value = new TextEncoder().encode(mockEvents[eventIdx++])
return { done: false, value }
}
return { done: true, value: undefined }
}),
}
const mockResponse = {
ok: true,
headers: {
get: vi.fn(() => 'sess-123'),
},
body: {
getReader: () => mockReader,
},
}
// eslint-disable-next-line @typescript-eslint/no-explicit-any
vi.mocked(client.api.teams[':teamId'].chat.$post).mockResolvedValue(mockResponse as any)
const sendPromise = useChatbotStore.getState().sendMessage('team-123', 'hello', 'proj-123')
// Optimistic message should be present immediately
const stateWithOptimistic = useChatbotStore.getState()
expect(stateWithOptimistic.messages).toHaveLength(1)
expect(stateWithOptimistic.messages[0].id).toContain('temp-')
await sendPromise
// Final state assertions: optimistic message must be replaced
const finalState = useChatbotStore.getState()
expect(finalState.messages).toHaveLength(2)
expect(finalState.messages[0].id).toBe('user-msg-ulid')
expect(finalState.messages[0].role).toBe('custom')
expect((finalState.messages[0] as { customType?: string }).customType).toBe('shumai_message')
expect(finalState.messages[1].id).toBe('assistant-msg-ulid')
})
})
+6 -2
View File
@@ -289,10 +289,14 @@ export const useChatbotStore = create<ChatbotState>((set) => ({
set((s) => {
const isExisting = s.messages.some((m) => m.id === entry.id)
const isUserMessage =
(entry.role === 'user' ||
(entry.role === 'custom' && entry.customType === 'shumai_message')) &&
!isExisting
// Replace temp/optimistic message when the real counterpart streams back
const filtered = s.messages.filter((m) => {
if (entry.role === 'user' && !isExisting) {
return !(m.id.startsWith('temp-') && !m.id.startsWith('temp-context-'))
if (isUserMessage) {
return !m.id.startsWith('temp-')
}
if (
entry.role === 'custom' &&
+1 -1
View File
@@ -1 +1 @@
export const APP_VERSION = '0.4.0'
export const APP_VERSION = '0.4.1'
+1 -1
View File
@@ -1,6 +1,6 @@
{
"name": "@shumai/workflow-core",
"version": "0.4.0",
"version": "0.4.1",
"private": true,
"type": "module",
"main": "./src/index.ts",
@@ -33,10 +33,6 @@ export class TemporalExecutor implements Executor {
workflowName = 'agentChatWorkflow'
taskQueue = TaskQueueAgent
break
case WorkflowTaskType.agent_tool_call:
workflowName = 'agentToolCallWorkflow'
taskQueue = TaskQueueAgent
break
case WorkflowTaskType.transcode:
workflowName = 'transcodeWorkflow'
taskQueue = TaskQueueTranscode