From c2348b0e683685b4885bbb1cb6f335034d1931dd Mon Sep 17 00:00:00 2001 From: Yiling-J Date: Sat, 31 Oct 2026 16:39:54 +0800 Subject: [PATCH] feat(upload): allow canceling in-progress upload tasks from sidebar (#511) * feat(upload): allow canceling in-progress upload tasks from sidebar * fix(upload): resolve concurrent confirmation race and store counter issues on cancellation * fix(webui): immediately remove cancelled upload files from file list view --- CHANGELOG.md | 1 + packages/api/src/upload.test.ts | 23 ++ packages/api/src/upload.ts | 15 + packages/core/src/upload/upload.test.ts | 259 ++++++++++++++++++ packages/core/src/upload/upload.ts | 154 +++++++---- packages/dtos/src/upload.ts | 6 + .../components/file-browser/file-browser.tsx | 55 ++-- .../webui/components/upload-tasks.test.tsx | 172 ++++++++++++ packages/webui/components/upload-tasks.tsx | 136 +++++++-- packages/webui/lib/uploader.test.ts | 30 ++ packages/webui/lib/uploader.ts | 25 +- packages/webui/messages/en.json | 7 +- packages/webui/messages/zh.json | 7 +- packages/webui/stores/upload.test.ts | 94 +++++++ packages/webui/stores/upload.ts | 35 +++ 15 files changed, 926 insertions(+), 93 deletions(-) create mode 100644 packages/webui/components/upload-tasks.test.tsx create mode 100644 packages/webui/stores/upload.test.ts diff --git a/CHANGELOG.md b/CHANGELOG.md index eb4b23c7..a2c3e872 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -8,6 +8,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/). ### Added +- **upload**: Allow users to cancel running upload tasks directly from the upload tasks sidebar with a confirmation dialog, preserving already completed files while discarding incomplete assets - **upload**: Improve upload resilience during network drops, device sleep, and transient gateway errors by adding state-based exponential backoff retries and extending upload link expiration to 12 hours ### Fixed diff --git a/packages/api/src/upload.test.ts b/packages/api/src/upload.test.ts index bc97dceb..ee314ff6 100644 --- a/packages/api/src/upload.test.ts +++ b/packages/api/src/upload.test.ts @@ -220,4 +220,27 @@ describe('Upload API', () => { key: 'files/test.mp4', }) }) + + it('POST /teams/:teamId/upload/tasks/:taskId/cancel', async () => { + vi.spyOn(uploadService, 'cancelUploadTask').mockResolvedValue({ + success: true, + }) + + const res = await app.request('/teams/team1/upload/tasks/task1/cancel', { + method: 'POST', + headers: { Authorization: 'Bearer test' }, + }) + + expect(res.status).toBe(200) + const json = await res.json() + expect(json).toEqual({ success: true }) + expect(authzService.hasPermission).toHaveBeenCalledWith( + expect.objectContaining({ + type: ResourceType.Team, + id: 'team1', + permission: Permission.Edit, + }), + ) + expect(uploadService.cancelUploadTask).toHaveBeenCalledWith('team1', 'user1', 'task1') + }) }) diff --git a/packages/api/src/upload.ts b/packages/api/src/upload.ts index a1461948..68be6da1 100644 --- a/packages/api/src/upload.ts +++ b/packages/api/src/upload.ts @@ -163,5 +163,20 @@ const route = new Hono<{ Variables: { user: User } }>() return c.json(resp) }, ) + .post('/teams/:teamId/upload/tasks/:taskId/cancel', async (c) => { + const teamId = c.req.param('teamId') + const taskId = c.req.param('taskId') + const user = c.get('user') + + await authzService.hasPermission({ + user, + permission: Permission.Edit, + type: ResourceType.Team, + id: teamId, + }) + + const resp = await uploadService.cancelUploadTask(teamId, user.id, taskId) + return c.json(resp) + }) export default route diff --git a/packages/core/src/upload/upload.test.ts b/packages/core/src/upload/upload.test.ts index bb0f64dc..a2751285 100644 --- a/packages/core/src/upload/upload.test.ts +++ b/packages/core/src/upload/upload.test.ts @@ -797,6 +797,7 @@ describe('UploadService', () => { expect(result.data).toHaveLength(1) expect(result.data[0].id).toBe(task.id) expect(result.data[0].name).toBe('test-upload-task') + expect(result.data[0].status).toBe(TaskStatus.pending) }) it('should correct the mediaType for .wma files that browser incorrectly reports as video', async () => { @@ -1120,4 +1121,262 @@ describe('UploadService', () => { expect(deletedAsset).toBeNull() }) }) + + describe('cancelUploadTask', () => { + it('cancels uploading assets, leaves uploaded assets and folders intact, and marks task failed', async () => { + const task = await prisma.task.create({ + data: { + creatorId: userId, + type: 'upload', + name: 'multi-file-task', + total: 3, + uploaded: 1, + status: TaskStatus.pending, + }, + }) + + // 1. A folder created by the task + const folder = await prisma.asset.create({ + data: { + name: 'subfolder', + type: AssetType.folder, + projectId, + parentId, + taskId: task.id, + status: AssetStatus.uploaded, + }, + }) + + // 2. An asset already finished uploading + const finishedKey = await prisma.storageKey.create({ data: { key: 'files/test/done.mp4' } }) + const finishedAsset = await prisma.asset.create({ + data: { + name: 'done.mp4', + type: AssetType.file, + projectId, + parentId: folder.id, + storageKeyId: finishedKey.id, + taskId: task.id, + status: AssetStatus.uploaded, + }, + }) + + // 3. An incomplete multipart asset + const multipartKey = await prisma.storageKey.create({ + data: { key: 'files/test/part.mp4' }, + }) + const multipartAsset = await prisma.asset.create({ + data: { + name: 'part.mp4', + type: AssetType.file, + projectId, + parentId: folder.id, + storageKeyId: multipartKey.id, + taskId: task.id, + uploadId: 'upload-multipart-cancel', + status: AssetStatus.uploading, + }, + }) + + // 4. An incomplete single PUT asset + const singleKey = await prisma.storageKey.create({ + data: { key: 'files/test/single.mp4' }, + }) + const singleAsset = await prisma.asset.create({ + data: { + name: 'single.mp4', + type: AssetType.file, + projectId, + parentId: folder.id, + storageKeyId: singleKey.id, + taskId: task.id, + status: AssetStatus.uploading, + }, + }) + + const res = await uploadService.cancelUploadTask(teamId, userId, task.id) + expect(res).toEqual({ success: true }) + + // Incomplete assets deleted + expect(await prisma.asset.findUnique({ where: { id: multipartAsset.id } })).toBeNull() + expect(await prisma.storageKey.findUnique({ where: { id: multipartKey.id } })).toBeNull() + expect(await prisma.asset.findUnique({ where: { id: singleAsset.id } })).toBeNull() + expect(await prisma.storageKey.findUnique({ where: { id: singleKey.id } })).toBeNull() + + // S3 cleanup called + expect(s3Service.abortMultipartUpload).toHaveBeenCalledWith( + expect.anything(), + 'files/test/part.mp4', + 'upload-multipart-cancel', + ) + expect(s3Service.deleteObject).toHaveBeenCalledWith( + expect.anything(), + 'files/test/single.mp4', + ) + + // Completed asset and folder remain intact + expect(await prisma.asset.findUnique({ where: { id: finishedAsset.id } })).not.toBeNull() + expect(await prisma.storageKey.findUnique({ where: { id: finishedKey.id } })).not.toBeNull() + expect(await prisma.asset.findUnique({ where: { id: folder.id } })).not.toBeNull() + + // Task status updated to failed + const updatedTask = await prisma.task.findUnique({ where: { id: task.id } }) + expect(updatedTask?.status).toBe(TaskStatus.failed) + expect(updatedTask?.uploaded).toBe(1) + }) + + it('rejects cancellation if the caller is not the task creator', async () => { + const otherUser = await prisma.user.create({ + data: { + email: 'other@example.com', + name: 'Other User', + }, + }) + + const task = await prisma.task.create({ + data: { + creatorId: otherUser.id, + type: 'upload', + name: 'other-task', + total: 1, + status: TaskStatus.pending, + }, + }) + + await expect(uploadService.cancelUploadTask(teamId, userId, task.id)).rejects.toThrow( + 'Unauthorized to cancel this upload task', + ) + }) + + it('throws when task does not exist', async () => { + await expect( + uploadService.cancelUploadTask(teamId, userId, 'non-existent-task'), + ).rejects.toThrow('Upload task not found') + }) + + it('throws when task assets belong to a different team', async () => { + const otherTeam = await prisma.team.create({ + data: { name: 'Other Team' }, + }) + const otherProject = await prisma.project.create({ + data: { name: 'Other Project', teamId: otherTeam.id }, + }) + + const task = await prisma.task.create({ + data: { + creatorId: userId, + type: 'upload', + name: 'wrong-team-task', + total: 1, + status: TaskStatus.pending, + }, + }) + + await prisma.asset.create({ + data: { + name: 'wrong-team-file.mp4', + type: AssetType.file, + projectId: otherProject.id, + taskId: task.id, + status: AssetStatus.uploading, + }, + }) + + await expect(uploadService.cancelUploadTask(teamId, userId, task.id)).rejects.toThrow( + 'Task does not belong to specified team', + ) + }) + + it('throws when task is already completed and preserves completed status', async () => { + const task = await prisma.task.create({ + data: { + creatorId: userId, + type: 'upload', + name: 'completed-task', + total: 1, + uploaded: 1, + status: TaskStatus.completed, + }, + }) + + await expect(uploadService.cancelUploadTask(teamId, userId, task.id)).rejects.toThrow( + 'Cannot cancel a completed upload task', + ) + + const refreshed = await prisma.task.findUnique({ where: { id: task.id } }) + expect(refreshed?.status).toBe(TaskStatus.completed) + }) + + it('preserves an asset and its storage if it was confirmed uploaded concurrently', async () => { + const task = await prisma.task.create({ + data: { + creatorId: userId, + type: 'upload', + name: 'race-task', + total: 2, + uploaded: 0, + status: TaskStatus.uploading, + }, + }) + + const confirmedAsset = await prisma.asset.create({ + data: { + name: 'race-confirmed.mp4', + type: AssetType.file, + project: { connect: { id: projectId } }, + task: { connect: { id: task.id } }, + status: AssetStatus.uploading, + storageKey: { + create: { key: 'files/test/race-confirmed.mp4' }, + }, + }, + include: { storageKey: true }, + }) + + const cancelledAsset = await prisma.asset.create({ + data: { + name: 'race-cancelled.mp4', + type: AssetType.file, + project: { connect: { id: projectId } }, + task: { connect: { id: task.id } }, + status: AssetStatus.uploading, + storageKey: { + create: { key: 'files/test/race-cancelled.mp4' }, + }, + }, + include: { storageKey: true }, + }) + + // Simulate concurrent confirm: update status to uploaded + await prisma.asset.update({ + where: { id: confirmedAsset.id }, + data: { status: AssetStatus.uploaded }, + }) + + const deleteObjectSpy = vi.spyOn(s3Service, 'deleteObject').mockResolvedValue(1) + + await uploadService.cancelUploadTask(teamId, userId, task.id) + + // Confirmed asset must still exist in DB + const dbConfirmed = await prisma.asset.findUnique({ where: { id: confirmedAsset.id } }) + expect(dbConfirmed).not.toBeNull() + expect(dbConfirmed?.status).toBe(AssetStatus.uploaded) + + // Cancelled asset must be deleted + const dbCancelled = await prisma.asset.findUnique({ where: { id: cancelledAsset.id } }) + expect(dbCancelled).toBeNull() + + // S3 deleteObject was called for the cancelled asset, but NOT for the confirmed asset + expect(deleteObjectSpy).toHaveBeenCalledWith( + expect.anything(), + 'files/test/race-cancelled.mp4', + ) + expect(deleteObjectSpy).not.toHaveBeenCalledWith( + expect.anything(), + 'files/test/race-confirmed.mp4', + ) + + deleteObjectSpy.mockRestore() + }) + }) }) diff --git a/packages/core/src/upload/upload.ts b/packages/core/src/upload/upload.ts index dd6963aa..8baf6967 100644 --- a/packages/core/src/upload/upload.ts +++ b/packages/core/src/upload/upload.ts @@ -5,6 +5,7 @@ import { AssetStatus, AssetType, Prisma, TaskStatus, prisma } from '@shumai/db' import { AbortUploadRequest, AbortUploadResponse, + CancelUploadTaskResponse, ConfirmFileUploadRequest, CreateUploadTaskRequest, CreateUploadTaskResponse, @@ -210,30 +211,7 @@ export class UploadService { if (!key) throw new Error('Asset has no key') if (req.errorMessage) { - const bucket = process.env.S3_BUCKET || 'shumai' - if (asset.uploadId && key) { - try { - await s3Service.abortMultipartUpload(bucket, key, asset.uploadId) - } catch (err) { - logger.warn( - { err, key, uploadId: asset.uploadId }, - 'Failed to abort multipart upload on confirm error', - ) - } - } else if (key) { - try { - await s3Service.deleteObject(bucket, key) - } catch (err) { - logger.warn({ err, key }, 'Failed to delete storage object on confirm error') - } - } - - await this.prismaClient.asset.delete({ where: { id: asset.id } }).catch(() => {}) - if (asset.storageKeyId) { - await this.prismaClient.storageKey - .delete({ where: { id: asset.storageKeyId } }) - .catch(() => {}) - } + await this.discardUploadingAsset(asset) const t = await this.prismaClient.task.findUnique({ where: { id: taskId } }) if (t) { const updatedTask = await this.prismaClient.task.update({ @@ -250,6 +228,10 @@ export class UploadService { return } + if (asset.status !== AssetStatus.uploading) { + throw new Error('Asset is not in uploading status') + } + const size = await s3Service.getObjectSize(process.env.S3_BUCKET || 'shumai', key) const project = asset.project @@ -425,6 +407,7 @@ export class UploadService { total: t.total || 0, uploaded: t.uploaded, createdAt: t.createdAt.toISOString(), + status: t.status, })) return { data: infos, pageInfo } @@ -490,7 +473,6 @@ export class UploadService { taskId: string, req: AbortUploadRequest, ): Promise { - const bucket = process.env.S3_BUCKET || 'shumai' const asset = await this.prismaClient.asset.findUnique({ where: { id: req.fileId }, include: { @@ -520,33 +502,11 @@ export class UploadService { throw new Error('Provided key does not match asset storage key') } - const uploadId = asset.uploadId || req.uploadId if (asset.uploadId && req.uploadId && asset.uploadId !== req.uploadId) { throw new Error('Provided uploadId does not match asset uploadId') } - if (uploadId && key) { - try { - await s3Service.abortMultipartUpload(bucket, key, uploadId) - } catch (err) { - logger.warn({ err, key, uploadId }, 'Failed to abort multipart upload in S3') - } - } else if (key) { - try { - await s3Service.deleteObject(bucket, key) - } catch (err) { - logger.warn({ err, key }, 'Failed to delete object from storage') - } - } - - await this.prismaClient.asset.delete({ where: { id: asset.id } }).catch((err) => { - logger.warn({ err, assetId: asset.id }, 'Failed to delete asset on upload abort') - }) - if (asset.storageKeyId) { - await this.prismaClient.storageKey - .delete({ where: { id: asset.storageKeyId } }) - .catch(() => {}) - } + await this.discardUploadingAsset(asset, req.uploadId) if (taskId) { const remaining = await this.prismaClient.asset.count({ @@ -564,6 +524,104 @@ export class UploadService { return { success: true } } + + private async discardUploadingAsset( + asset: { + id: string + uploadId: string | null + storageKeyId: string | null + storageKey: { key: string } | null + }, + requestedUploadId?: string, + ): Promise { + const deleteResult = await this.prismaClient.asset.deleteMany({ + where: { + id: asset.id, + status: AssetStatus.uploading, + }, + }) + + if (deleteResult.count === 0) { + return + } + + const bucket = process.env.S3_BUCKET || 'shumai' + const key = asset.storageKey?.key + const uploadId = asset.uploadId || requestedUploadId + + if (uploadId && key) { + try { + await s3Service.abortMultipartUpload(bucket, key, uploadId) + } catch (err) { + logger.warn({ err, key, uploadId }, 'Failed to abort multipart upload in S3') + } + } else if (key) { + try { + await s3Service.deleteObject(bucket, key) + } catch (err) { + logger.warn({ err, key }, 'Failed to delete object from storage') + } + } + + if (asset.storageKeyId) { + await this.prismaClient.storageKey + .delete({ where: { id: asset.storageKeyId } }) + .catch(() => {}) + } + } + + async cancelUploadTask( + teamId: string, + userId: string, + taskId: string, + ): Promise { + const task = await this.prismaClient.task.findUnique({ + where: { id: taskId }, + include: { + assets: { + include: { + storageKey: true, + project: true, + }, + }, + }, + }) + + if (!task) { + throw new Error('Upload task not found') + } + + if (task.creatorId !== userId) { + throw new Error('Unauthorized to cancel this upload task') + } + + if (task.status === TaskStatus.completed) { + throw new Error('Cannot cancel a completed upload task') + } + + const invalidTeamAsset = task.assets.find( + (a) => a.project?.teamId && a.project.teamId !== teamId, + ) + if (invalidTeamAsset) { + throw new Error('Task does not belong to specified team') + } + + const uploadingAssets = task.assets.filter((a) => a.status === AssetStatus.uploading) + + for (const asset of uploadingAssets) { + await this.discardUploadingAsset(asset) + } + + await this.prismaClient.task.updateMany({ + where: { + id: taskId, + status: { not: TaskStatus.completed }, + }, + data: { status: TaskStatus.failed }, + }) + + return { success: true } + } } export const uploadService = new UploadService() diff --git a/packages/dtos/src/upload.ts b/packages/dtos/src/upload.ts index 610c487e..3b3f204d 100644 --- a/packages/dtos/src/upload.ts +++ b/packages/dtos/src/upload.ts @@ -75,6 +75,11 @@ export const abortUploadResponseSchema = z.object({ }) export type AbortUploadResponse = z.infer +export const cancelUploadTaskResponseSchema = z.object({ + success: z.boolean(), +}) +export type CancelUploadTaskResponse = z.infer + export const confirmFileUploadRequestSchema = z.object({ fileId: z.string(), errorMessage: z.string().optional(), @@ -87,6 +92,7 @@ export const taskInfoSchema = z.object({ total: z.number(), uploaded: z.number(), createdAt: z.string(), + status: z.enum(['pending', 'uploading', 'completed', 'failed']).optional(), }) export type TaskInfo = z.infer diff --git a/packages/webui/components/file-browser/file-browser.tsx b/packages/webui/components/file-browser/file-browser.tsx index 1cedb77b..dd798a0b 100644 --- a/packages/webui/components/file-browser/file-browser.tsx +++ b/packages/webui/components/file-browser/file-browser.tsx @@ -250,12 +250,15 @@ export function FileBrowser({ } const [localUploadingFiles, setLocalUploadingFiles] = useState([]) + const fileProgress = useUploadStore((state) => state.fileProgress) const displayedFiles = useMemo(() => { const existingIds = new Set(files.map((f) => f.id)) - const filteredLocal = localUploadingFiles.filter((f) => !existingIds.has(f.id)) + const filteredLocal = localUploadingFiles + .filter((f) => !existingIds.has(f.id)) + .filter((f) => fileProgress[f.id!]?.status !== 'failed') return [...filteredLocal, ...files] - }, [files, localUploadingFiles]) + }, [files, localUploadingFiles, fileProgress]) const activePreviewItem = useMemo(() => { if (selectedIds.size === 0) return null @@ -575,6 +578,7 @@ export function FileBrowser({ startTask(data.taskId, taskName, filesProgressInfo) } + let batchIds: Set | null = null if (isCurrentFolderUpload) { const newLocalFiles: AssetInfo[] = currentFiles .filter((f) => { @@ -615,6 +619,7 @@ export function FileBrowser({ updatedAt: new Date().toISOString(), } }) + batchIds = new Set(newLocalFiles.map((f) => f.id!)) setLocalUploadingFiles((prev) => [...newLocalFiles, ...prev]) } @@ -626,26 +631,32 @@ export function FileBrowser({ queryKey: ['teams', teamId, 'upload', 'tasks'], }) - await uploadFilesWithUppy({ - files: currentFiles, - taskId: data.taskId!, - teamId: teamId!, - storageBackend: (data.storageBackend as 's3' | 'local') || 'local', - createdAssets: data.createdAssets, - presignedUrls: data.presignedUrls, - onFileFinished: async (fileId) => { - await queryClient.invalidateQueries({ - queryKey: ['search', teamId, assetId], - }) - setLocalUploadingFiles((prev) => prev.filter((f) => f.id !== fileId)) - }, - }) - queryClient.invalidateQueries({ - queryKey: ['search', teamId, assetId], - }) - queryClient.invalidateQueries({ - queryKey: ['teams', teamId, 'upload', 'tasks'], - }) + try { + await uploadFilesWithUppy({ + files: currentFiles, + taskId: data.taskId!, + teamId: teamId!, + storageBackend: (data.storageBackend as 's3' | 'local') || 'local', + createdAssets: data.createdAssets, + presignedUrls: data.presignedUrls, + onFileFinished: async (fileId) => { + await queryClient.invalidateQueries({ + queryKey: ['search', teamId, assetId], + }) + setLocalUploadingFiles((prev) => prev.filter((f) => f.id !== fileId)) + }, + }) + } finally { + if (batchIds) { + setLocalUploadingFiles((prev) => prev.filter((f) => !batchIds!.has(f.id!))) + } + queryClient.invalidateQueries({ + queryKey: ['search', teamId, assetId], + }) + queryClient.invalidateQueries({ + queryKey: ['teams', teamId, 'upload', 'tasks'], + }) + } }, }) diff --git a/packages/webui/components/upload-tasks.test.tsx b/packages/webui/components/upload-tasks.test.tsx new file mode 100644 index 00000000..a1217c53 --- /dev/null +++ b/packages/webui/components/upload-tasks.test.tsx @@ -0,0 +1,172 @@ +// @vitest-environment happy-dom +import { cleanup, render, screen, fireEvent, waitFor } from '@testing-library/react' +import React from 'react' +import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest' +import { QueryClient, QueryClientProvider } from '@tanstack/react-query' +import { UploadTasks } from './upload-tasks' +import { useUploadStore } from '@/ui/stores/upload' +import * as uploaderLib from '@/ui/lib/uploader' +import { toast } from 'sonner' + +const mockGetTasks = vi.fn() +const mockCancelTask = vi.fn() + +vi.mock('@/ui/api/client', () => ({ + client: { + api: { + teams: { + ':teamId': { + upload: { + tasks: Object.assign( + { + $get: () => mockGetTasks(), + }, + { + ':taskId': { + cancel: { + $post: (args: unknown) => mockCancelTask(args), + }, + }, + }, + ), + }, + }, + }, + }, + }, +})) + +vi.mock('@/ui/hooks/use-team-id', () => ({ + useTeamId: () => 'team-1', +})) + +vi.mock('sonner', () => ({ + toast: { + success: vi.fn(), + error: vi.fn(), + }, +})) + +describe('UploadTasks', () => { + let queryClient: QueryClient + + beforeEach(() => { + vi.clearAllMocks() + queryClient = new QueryClient({ + defaultOptions: { + queries: { retry: false }, + }, + }) + useUploadStore.setState({ + uploading: 0, + tasks: {}, + fileProgress: {}, + }) + }) + + afterEach(() => { + cleanup() + }) + + it('renders completed and failed tasks without a cancel button', async () => { + mockGetTasks.mockResolvedValue({ + ok: true, + json: async () => ({ + data: [ + { + id: 'task-done', + name: 'Completed Task', + total: 2, + uploaded: 2, + status: 'completed', + createdAt: new Date().toISOString(), + }, + { + id: 'task-failed', + name: 'Failed Task', + total: 2, + uploaded: 1, + status: 'failed', + createdAt: new Date().toISOString(), + }, + ], + pageInfo: {}, + }), + }) + + render( + + + , + ) + + await waitFor(() => { + expect(screen.getByText('Completed Task')).toBeDefined() + expect(screen.getByText('Failed Task')).toBeDefined() + }) + + // No cancel button should be rendered for completed or failed tasks + expect(screen.queryByRole('button', { name: /cancel/i })).toBeNull() + }) + + it('renders cancel button for running tasks and executes cancel flow on confirmation', async () => { + const cancelActiveSpy = vi.spyOn(uploaderLib, 'cancelActiveUploadTask') + + mockGetTasks.mockResolvedValue({ + ok: true, + json: async () => ({ + data: [ + { + id: 'task-running', + name: 'Running Task', + total: 3, + uploaded: 1, + status: 'uploading', + createdAt: new Date().toISOString(), + }, + ], + pageInfo: {}, + }), + }) + + mockCancelTask.mockResolvedValue({ + ok: true, + json: async () => ({ success: true }), + }) + + render( + + + , + ) + + await waitFor(() => { + expect(screen.getByText('Running Task')).toBeDefined() + }) + + // Cancel button should be present + const cancelButton = screen.getByRole('button', { name: /cancel/i }) + expect(cancelButton).toBeDefined() + + // Click Cancel to open confirmation dialog + fireEvent.click(cancelButton) + + await waitFor(() => { + expect(screen.getByText(/cancel upload task\?/i)).toBeDefined() + }) + + // Click confirm in the dialog + const confirmButtons = screen.getAllByRole('button', { name: /cancel upload/i }) + fireEvent.click(confirmButtons[confirmButtons.length - 1]) + + await waitFor(() => { + expect(cancelActiveSpy).toHaveBeenCalledWith('task-running') + expect(mockCancelTask).toHaveBeenCalledWith( + expect.objectContaining({ + param: { teamId: 'team-1', taskId: 'task-running' }, + }), + ) + expect(toast.success).toHaveBeenCalled() + }) + }) +}) diff --git a/packages/webui/components/upload-tasks.tsx b/packages/webui/components/upload-tasks.tsx index 976c2cc6..88c030cf 100644 --- a/packages/webui/components/upload-tasks.tsx +++ b/packages/webui/components/upload-tasks.tsx @@ -1,13 +1,26 @@ import { client } from '@/ui/api/client' import type { TaskInfo } from '@shumai/dtos' import { useTeamId } from '@/ui/hooks/use-team-id' -import { useInfiniteQuery } from '@tanstack/react-query' +import { useInfiniteQuery, useMutation, useQueryClient } from '@tanstack/react-query' import { useUploadStore } from '@/ui/stores/upload' -import { Loader2, CheckCircle2, Clock, UploadCloud } from 'lucide-react' -import { useEffect, useMemo } from 'react' +import { cancelActiveUploadTask } from '@/ui/lib/uploader' +import { Loader2, CheckCircle2, Clock, UploadCloud, AlertCircle } from 'lucide-react' +import { useEffect, useMemo, useState } from 'react' import { useInView } from 'react-intersection-observer' import { format, parseISO, isToday, isYesterday } from 'date-fns' import { Progress } from '@/ui/components/ui/progress' +import { Button } from '@/ui/components/ui/button' +import { + AlertDialog, + AlertDialogAction, + AlertDialogCancel, + AlertDialogContent, + AlertDialogDescription, + AlertDialogFooter, + AlertDialogHeader, + AlertDialogTitle, +} from '@/ui/components/ui/alert-dialog' +import { toast } from 'sonner' import { formatTimeAgo } from '@/ui/lib/time' import { m } from '@/ui/paraglide/messages.js' @@ -33,20 +46,29 @@ function formatBytes(bytes: number): string { return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + ' ' + sizes[i] } -function UploadTaskItem({ task }: { task: TaskInfo }) { +function UploadTaskItem({ task, teamId }: { task: TaskInfo; teamId?: string }) { + const [isCancelConfirmOpen, setIsCancelConfirmOpen] = useState(false) const clientProgress = useUploadStore((state) => state.tasks[task.id]) + const cancelTaskInStore = useUploadStore((state) => state.cancelTask) + const queryClient = useQueryClient() const isCompleted = clientProgress ? clientProgress.loaded === clientProgress.total && task.uploaded === task.total : task.uploaded === task.total - const percent = clientProgress - ? clientProgress.total > 0 - ? (clientProgress.loaded / clientProgress.total) * 100 - : 0 - : task.total > 0 - ? (task.uploaded / task.total) * 100 - : 0 + const isFailed = task.status === 'failed' + const isDone = task.status === 'completed' || isCompleted + const isRunning = !isDone && !isFailed + + const percent = isDone + ? 100 + : clientProgress + ? clientProgress.total > 0 + ? (clientProgress.loaded / clientProgress.total) * 100 + : 0 + : task.total > 0 + ? (task.uploaded / task.total) * 100 + : 0 let formattedTime: string try { @@ -55,6 +77,37 @@ function UploadTaskItem({ task }: { task: TaskInfo }) { formattedTime = m.unknown() } + const { mutate: cancelMutation, isPending: isCanceling } = useMutation({ + mutationFn: async () => { + cancelActiveUploadTask(task.id) + cancelTaskInStore(task.id) + + if (teamId) { + const res = await client.api.teams[':teamId'].upload.tasks[':taskId'].cancel.$post({ + param: { teamId, taskId: task.id }, + }) + if (!res.ok) { + throw new Error('Failed to cancel upload task') + } + return await res.json() + } + }, + onSuccess: () => { + setIsCancelConfirmOpen(false) + toast.success(m.upload_task_canceled()) + queryClient.invalidateQueries({ + queryKey: ['teams', teamId, 'upload', 'tasks'], + }) + queryClient.invalidateQueries({ + queryKey: ['search', teamId], + }) + }, + onError: (err) => { + console.error('Failed to cancel upload task:', err) + toast.error(m.failed_to_cancel_upload_task()) + }, + }) + return (
{/* Top row: Name & Status Badge */} @@ -68,11 +121,16 @@ function UploadTaskItem({ task }: { task: TaskInfo }) {
- {isCompleted ? ( + {isDone ? ( {m.done()} + ) : isFailed ? ( + + + {m.status_failed()} + ) : ( @@ -88,7 +146,7 @@ function UploadTaskItem({ task }: { task: TaskInfo }) { {formattedTime}
- {/* Bottom row: Progress Bar and Fraction */} + {/* Bottom row: Progress Bar, Fraction & Cancel Button */}
@@ -96,12 +154,56 @@ function UploadTaskItem({ task }: { task: TaskInfo }) { ? `${formatBytes(clientProgress.loaded)} / ${formatBytes(clientProgress.total)} (${m.files_progress({ uploaded: task.uploaded, total: task.total })})` : m.files_progress({ uploaded: task.uploaded, total: task.total })} - {!isCompleted && ( - {Math.round(percent)}% - )} +
+ {!isDone && !isFailed && ( + + {Math.round(percent)}% + + )} + {isRunning && ( + + )} +
+ + + + + {m.cancel_upload_task_confirm_title()} + + {m.cancel_upload_task_confirm_description()} + + + + {m.cancel()} + { + e.preventDefault() + cancelMutation() + }} + className="bg-destructive text-destructive-foreground hover:bg-destructive/90" + > + {isCanceling ? : null} + {m.cancel_upload_task()} + + + + ) } @@ -218,7 +320,7 @@ export function UploadTasks() { {/* Tasks in Day */}
{group.tasks.map((task) => ( - + ))}
diff --git a/packages/webui/lib/uploader.test.ts b/packages/webui/lib/uploader.test.ts index 8e59b213..66c550da 100644 --- a/packages/webui/lib/uploader.test.ts +++ b/packages/webui/lib/uploader.test.ts @@ -2,6 +2,7 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest' import { activeUploads, + cancelActiveUploadTask, uploadFilesWithUppy, isNetworkIssue, isLocalhostStorageMismatch, @@ -856,4 +857,33 @@ describe('Uploader', () => { addFileSpy.mockRestore() }) + + it('cancelActiveUploadTask cancels in-flight uppy upload and cleans up activeUploads', async () => { + useUploadStore + .getState() + .startTask('task-cancel', 'Task Cancel', [ + { fileId: 'file-c1', name: 'cancel.mp4', size: 1000 }, + ]) + + const uploadPromise = uploadFilesWithUppy({ + files: [ + { + id: 'temp-c1', + file: new File(['data'], 'cancel.mp4', { type: 'video/mp4' }), + }, + ], + taskId: 'task-cancel', + teamId: 'team-1', + storageBackend: 's3', + createdAssets: [{ tempId: 'temp-c1', assetId: 'file-c1', key: 'files/cancel.mp4' }], + }) + + await new Promise((r) => setTimeout(r, 10)) + expect(activeUploads.has('file-c1')).toBe(true) + + cancelActiveUploadTask('task-cancel') + + expect(activeUploads.has('file-c1')).toBe(false) + await expect(uploadPromise).resolves.toBeUndefined() + }) }) diff --git a/packages/webui/lib/uploader.ts b/packages/webui/lib/uploader.ts index fb3427a8..e39b44ba 100644 --- a/packages/webui/lib/uploader.ts +++ b/packages/webui/lib/uploader.ts @@ -23,6 +23,24 @@ export interface ActiveUploadFile { } export const activeUploads = new Map() +export const activeUppyByTaskId = new Map() + +export function cancelActiveUploadTask(taskId: string): void { + const uppy = activeUppyByTaskId.get(taskId) + if (uppy) { + try { + uppy.cancelAll() + } catch (err) { + console.warn('Failed to cancel uppy uploads:', err) + } + } + + for (const [fileId, item] of activeUploads.entries()) { + if (item.taskId === taskId) { + activeUploads.delete(fileId) + } + } +} // Setup beforeunload and pagehide listeners once if (typeof window !== 'undefined') { @@ -237,7 +255,7 @@ export async function uploadFilesWithUppy({ await acquireWakeLock() const store = useUploadStore.getState() - const { increment, decrement, updateFileProgress, completeFile, failFile } = store + const { increment, updateFileProgress, completeFile, failFile } = store // Build lookup maps const assetByTempId = new Map() @@ -258,6 +276,7 @@ export async function uploadFilesWithUppy({ autoProceed: true, allowMultipleUploadBatches: false, }) + activeUppyByTaskId.set(taskId, uppy) if (storageBackend === 's3') { uppy.use(AwsS3, { @@ -417,12 +436,10 @@ export async function uploadFilesWithUppy({ throw new Error(`Failed to confirm upload: ${res.statusText}`) } completeFile(taskId, fileId) - decrement() await onFileFinished?.(fileId) } catch (err) { console.error('Failed to confirm upload:', err) failFile(taskId, fileId) - decrement() toast.error(m.failed_confirm_upload_with_name({ name: file.name })) await onFileFinished?.(fileId) throw err @@ -443,7 +460,6 @@ export async function uploadFilesWithUppy({ activeUploads.delete(fileId) failFile(taskId, fileId) - decrement() if (isLocalhostStorageMismatch(uploadUrl)) { toast.error(m.upload_failed_s3_endpoint_localhost(), { @@ -600,6 +616,7 @@ export async function uploadFilesWithUppy({ await Promise.allSettled(Array.from(confirmationPromises.values())) } finally { + activeUppyByTaskId.delete(taskId) if (retryTimeout) { clearTimeout(retryTimeout) } diff --git a/packages/webui/messages/en.json b/packages/webui/messages/en.json index 4fbeaf55..2030f594 100644 --- a/packages/webui/messages/en.json +++ b/packages/webui/messages/en.json @@ -1607,5 +1607,10 @@ "deny": "Deny", "denying": "Denying...", "consent_failed": "Failed to process authorization", - "mcp_access_scope_desc": "Full user-level access to Shumai workspace and MCP tools" + "mcp_access_scope_desc": "Full user-level access to Shumai workspace and MCP tools", + "cancel_upload_task": "Cancel upload", + "cancel_upload_task_confirm_title": "Cancel upload task?", + "cancel_upload_task_confirm_description": "Files that have already finished uploading will be kept in your project. Any incomplete or pending uploads will be canceled and removed.", + "upload_task_canceled": "Upload task canceled", + "failed_to_cancel_upload_task": "Failed to cancel upload task" } diff --git a/packages/webui/messages/zh.json b/packages/webui/messages/zh.json index dec8f4b9..6a6ed3fc 100644 --- a/packages/webui/messages/zh.json +++ b/packages/webui/messages/zh.json @@ -1607,5 +1607,10 @@ "deny": "拒绝", "denying": "拒绝中...", "consent_failed": "处理授权失败", - "mcp_access_scope_desc": "以当前用户权限完全访问 Shumai 工作空间及 MCP 工具" + "mcp_access_scope_desc": "以当前用户权限完全访问 Shumai 工作空间及 MCP 工具", + "cancel_upload_task": "取消上传", + "cancel_upload_task_confirm_title": "取消上传任务?", + "cancel_upload_task_confirm_description": "已完成上传的文件将保留在项目中。任何未完成或等待中的上传将被取消并移除。", + "upload_task_canceled": "上传任务已取消", + "failed_to_cancel_upload_task": "取消上传任务失败" } diff --git a/packages/webui/stores/upload.test.ts b/packages/webui/stores/upload.test.ts new file mode 100644 index 00000000..7bf51875 --- /dev/null +++ b/packages/webui/stores/upload.test.ts @@ -0,0 +1,94 @@ +import { describe, it, expect, beforeEach } from 'vitest' +import { useUploadStore } from './upload' + +describe('useUploadStore', () => { + beforeEach(() => { + useUploadStore.setState({ + uploading: 0, + tasks: {}, + fileProgress: {}, + }) + }) + + it('starts task and tracks initial progress', () => { + useUploadStore.getState().startTask('task-1', 'My Task', [ + { fileId: 'f1', name: 'video1.mp4', size: 1000 }, + { fileId: 'f2', name: 'video2.mp4', size: 2000 }, + ]) + + const state = useUploadStore.getState() + expect(state.tasks['task-1']).toBeDefined() + expect(state.tasks['task-1'].name).toBe('My Task') + expect(state.tasks['task-1'].total).toBe(3000) + expect(state.tasks['task-1'].loaded).toBe(0) + expect(state.tasks['task-1'].files['f1'].status).toBe('uploading') + expect(state.tasks['task-1'].files['f2'].status).toBe('uploading') + }) + + it('updates file progress and task loaded bytes', () => { + useUploadStore.getState().startTask('task-1', 'My Task', [ + { fileId: 'f1', name: 'video1.mp4', size: 1000 }, + { fileId: 'f2', name: 'video2.mp4', size: 2000 }, + ]) + + useUploadStore.getState().updateFileProgress('task-1', 'f1', 500) + expect(useUploadStore.getState().tasks['task-1'].loaded).toBe(500) + expect(useUploadStore.getState().fileProgress['f1'].loaded).toBe(500) + + useUploadStore.getState().completeFile('task-1', 'f1') + expect(useUploadStore.getState().tasks['task-1'].files['f1'].status).toBe('completed') + expect(useUploadStore.getState().tasks['task-1'].files['f1'].loaded).toBe(1000) + expect(useUploadStore.getState().tasks['task-1'].loaded).toBe(1000) + }) + + it('cancelTask marks incomplete files as failed and decrements uploading count', () => { + useUploadStore.setState({ uploading: 3 }) + useUploadStore.getState().startTask('task-1', 'My Task', [ + { fileId: 'f1', name: 'done.mp4', size: 1000 }, + { fileId: 'f2', name: 'stuck1.mp4', size: 2000 }, + { fileId: 'f3', name: 'stuck2.mp4', size: 3000 }, + ]) + + // f1 completes (automatically decrements uploading from 3 to 2) + useUploadStore.getState().completeFile('task-1', 'f1') + expect(useUploadStore.getState().uploading).toBe(2) + + // cancelTask is called + useUploadStore.getState().cancelTask('task-1') + + const task = useUploadStore.getState().tasks['task-1'] + expect(task.files['f1'].status).toBe('completed') + expect(task.files['f2'].status).toBe('failed') + expect(task.files['f3'].status).toBe('failed') + expect(useUploadStore.getState().fileProgress['f2'].status).toBe('failed') + expect(useUploadStore.getState().fileProgress['f3'].status).toBe('failed') + expect(useUploadStore.getState().uploading).toBe(0) + }) + + it('does not decrement uploading count twice if completeFile or failFile is called after cancelTask', () => { + useUploadStore.setState({ uploading: 2 }) + useUploadStore.getState().startTask('task-1', 'My Task', [ + { fileId: 'f1', name: 'in-flight.mp4', size: 1000 }, + { fileId: 'f2', name: 'waiting.mp4', size: 2000 }, + ]) + + // Cancel task while f1 confirmation was in-flight + useUploadStore.getState().cancelTask('task-1') + expect(useUploadStore.getState().uploading).toBe(0) + expect(useUploadStore.getState().tasks['task-1'].files['f1'].status).toBe('failed') + + // In-flight confirmation settles late + useUploadStore.getState().completeFile('task-1', 'f1') + expect(useUploadStore.getState().uploading).toBe(0) + + // Another late error settles + useUploadStore.getState().failFile('task-1', 'f2') + expect(useUploadStore.getState().uploading).toBe(0) + }) + + it('cancelTask gracefully handles non-existent task', () => { + useUploadStore.setState({ uploading: 1 }) + useUploadStore.getState().cancelTask('non-existent') + expect(useUploadStore.getState().uploading).toBe(1) + }) +}) diff --git a/packages/webui/stores/upload.ts b/packages/webui/stores/upload.ts index 26db600f..b28e65f0 100644 --- a/packages/webui/stores/upload.ts +++ b/packages/webui/stores/upload.ts @@ -30,6 +30,7 @@ type UploadStore = { updateFileProgress: (taskId: string, fileId: string, loaded: number) => void completeFile: (taskId: string, fileId: string) => void failFile: (taskId: string, fileId: string) => void + cancelTask: (taskId: string) => void } export const useUploadStore = create((set) => ({ @@ -114,12 +115,14 @@ export const useUploadStore = create((set) => ({ const file = task.files[fileId] if (!file) return {} + const wasUploading = file.status === 'uploading' const updatedFile: FileUploadState = { ...file, status: 'completed', loaded: file.total } const updatedFiles = { ...task.files, [fileId]: updatedFile } const loadedBytes = Object.values(updatedFiles).reduce((sum, f) => sum + f.loaded, 0) return { + uploading: wasUploading ? Math.max(0, state.uploading - 1) : state.uploading, tasks: { ...state.tasks, [taskId]: { @@ -143,12 +146,14 @@ export const useUploadStore = create((set) => ({ const file = task.files[fileId] if (!file) return {} + const wasUploading = file.status === 'uploading' const updatedFile: FileUploadState = { ...file, status: 'failed' } const updatedFiles = { ...task.files, [fileId]: updatedFile } const loadedBytes = Object.values(updatedFiles).reduce((sum, f) => sum + f.loaded, 0) return { + uploading: wasUploading ? Math.max(0, state.uploading - 1) : state.uploading, tasks: { ...state.tasks, [taskId]: { @@ -163,4 +168,34 @@ export const useUploadStore = create((set) => ({ }, } }), + + cancelTask: (taskId) => + set((state) => { + const task = state.tasks[taskId] + if (!task) return {} + + let decrements = 0 + const updatedFiles = { ...task.files } + const updatedFileProgress = { ...state.fileProgress } + + for (const [fileId, file] of Object.entries(task.files)) { + if (file.status === 'uploading') { + updatedFiles[fileId] = { ...file, status: 'failed' } + updatedFileProgress[fileId] = { ...file, status: 'failed' } + decrements++ + } + } + + return { + uploading: Math.max(0, state.uploading - decrements), + tasks: { + ...state.tasks, + [taskId]: { + ...task, + files: updatedFiles, + }, + }, + fileProgress: updatedFileProgress, + } + }), }))