Compare commits

...
103 Commits
Author SHA1 Message Date
yiling 76ffb51bb2 Release v0.4.6 2026-09-17 21:58:10 +08:00
Yiling-J ca94e51424 fix(api): enforce SHUMAI_DEMO_MODE for API token and CLI requests (#413) 2026-09-17 21:47:07 +08:00
Yiling-J d8621a53b6 docs: add NLE export and Premiere Pro UXP plugin documentation (#412)
* docs: add NLE export and Premiere Pro UXP plugin documentation

* docs: mark Premiere Pro UXP plugin as experimental
2026-09-17 21:32:41 +08:00
Yiling-J e2f741eda6 feat(settings): add team appearance setting to hide agent features (#411)
* feat(settings): add team appearance setting to hide agent features

Add an Appearance subpage under Team Settings allowing team owners to toggle appearance.hideAgent for the team. Return appearance.hideAgent in the user-metadata API, and conditionally hide the AGENTS.md button, agent chatbot sidebar, and chatbot trigger button in the WebUI.

* refactor(settings): add strongly typed TeamSettingsResponse to remove explicit any

Introduce TeamSettingsResponse and TeamAppearanceSettings in @shumai/dtos, type TeamService.getSettings and updateSettings, and eliminate the explicit any cast in AppearanceSettings.tsx.
2026-09-17 18:31:43 +08:00
Yiling-J 7af3647913 fix(premiere-uxp): scope sequence links by server endpoint and surface sync errors (#409)
* fix(premiere-uxp): scope sequence links by server endpoint and surface sync errors

- Add optional endpoint property to LinkedSequenceAsset to record originating server
- Implement normalizeEndpoint and isSameEndpoint helpers in utils/url
- Skip polling foreign sequence links in autoSyncService when connected to a different server
- Display informative Server: <host> badge and disable manual sync with tooltip for foreign links in SequencesView
- Guard comment fallback in removeSequenceLink and link matching in FileListView by endpoint
- Throw on non-200 responses in fetchAssetComments and display error toast on failed manual sync
- Add comprehensive unit tests covering endpoint normalization, foreign link skipping, and error toast handling
- Rebuild and package shumai-premiere.ccx

* fix(premiere-uxp): filter out foreign endpoint sequence links from sequences tab

- Filter all sequence links in SequencesView to only display links matching the current server endpoint
- Filter existing sequence links in LinkSequenceDialog by endpoint so foreign sequences appear as ready to link on the current server
- Ensure onLinkCountChange in FileListView and SequencesView only counts sequences linked to the active server
- Add 'Browse Assets to Link' action button to the SequencesView unified empty state
- Update SequencesView tests to verify foreign links are completely hidden and link counts are scoped
- Rebuild and package shumai-premiere.ccx

* fix(premiere-uxp): show file creation time on cards and remove sequence icon in link dialog

* fix(premiere-uxp): remove browse button in sequences empty state
2026-09-17 16:37:11 +08:00
Yiling-J 12f99797d2 fix(premiere-uxp): preserve remote cloud storage presigned URLs in asset resolution (#408)
- Stop rewriting absolute URLs in resolveAssetUrl to prevent overwriting cloud storage hosts (e.g. Cloudflare R2, S3) with the plugin endpoint
- Prepend endpoint to relative paths only (e.g. /files/..., /api/...)
- Resolve download URLs through resolveAssetUrl before fetch in importAssetIntoPremiere
- Update unit tests to ensure absolute URLs remain intact and relative download paths resolve correctly
- Rebuild and package shumai-premiere.ccx
2026-09-17 16:37:11 +08:00
Yiling-J 1796de8eda feat(premiere-uxp): introduce Adobe Premiere Pro UXP plugin for Shumai (#407)
* feat(premiere-uxp): use native Bun bundler and build script instead of Vite

* feat(premiere-uxp): switch FileListView to use Search API consistent with WebUI

* feat(premiere-uxp): add on-demand jpeg preview conversion for uxp compatibility

* feat(premiere-uxp): integrate spectrum web components (swc)

* fix(premiere-uxp): align swc packages with 0.37.0 and fix auth layout

* feat(premiere-uxp): use horizontal 2-column card view for projects and files

* style(premiere-uxp): enlarge file preview by 20% and add row padding

* fix(premiere-uxp): prevent card squishing and overflow with large item counts

* fix(premiere-uxp): change host in manifest to single object

* docs(premiere-uxp): add AGENTS.md with SWC preferences and UXP layout rules

* feat(premiere-uxp): integrate spectrum web components across plugin views

* fix(premiere-uxp): remove breadcrumb icons and use slash separator

* feat(premiere-uxp): add collapsible folder and file sections with infinite scroll

* feat(premiere-uxp): update file card layout with right column info and clean preview

* fix(premiere-uxp): use raw text for file card details and fix black icons

* style(premiere-uxp): use contain object-fit and black background for file card preview

* fix(premiere-uxp): refine header logo, sticky title bars, circular badges, and controls

* fix(premiere-uxp): replace stroke icons with spectrum workflow icons

* fix(premiere-uxp): switch icon buttons to swc sp-button with icon-only and slot=icon

* fix(premiere-uxp): vertically center endpoint text in header

* feat(premiere-uxp): add asset and proxy import support into Premiere Pro

- Implement context menu on file cards with left-click, right-click, and more action button triggers
- Support raw file import for non-video assets and video assets
- Support video proxy submenu listing ready transcode resolutions
- Add UXP native file picker save dialog and binary download orchestration
- Call Premiere Pro project.importFiles API to import downloaded assets into active project
- Add non-blocking toast notification banner for progress and status reporting
- Add unit tests for premiere host service and import orchestration

* fix(premiere-uxp): anchor import menu directly to file card using sp-action-menu

- Replace custom fixed-position ContextMenu with native SWC sp-action-menu
- Anchor menu directly to the triggered file card rather than the top-left window corner
- Support programmatic opening on file card click/contextmenu via imperative handle
- Support video submenu with Original and ready proxy options inside sp-action-menu
- Lazy load video proxies on menu open or hover
- Clean up obsolete fixed-position styles and unused backdrop overlays

* fix(premiere-uxp): align SWC packages to 0.37.0 and guard custom element registry

- Downgrade action-menu and menu SWC packages to 0.37.0 to match the rest of the workspace
- Eliminate duplicate icons-ui and sp-icon-chevron100 customElements.define calls
- Add polyfill guard to customElements.define to prevent duplicate registration errors during UXP reload

* fix(premiere-uxp): polyfill window.matchMedia for Adobe UXP

- Add window.matchMedia polyfill in polyfills.ts
- Satisfies SWC MatchMediaController used by ActionMenu and PickerBase in UXP
- Prevents TypeError when opening files page

* feat(premiere-uxp): replace context menu with card download action and video import dialog

* fix(premiere-uxp): resolve download url before save, pass null targetBin, and center download icon

* fix(premiere-uxp): resolve raw download url via download-url endpoint with fallback

* feat(premiere-uxp): use native folder picker and auto-increment conflict suffixes

* feat(premiere-uxp): add sequence linking, comment-marker sync, and navigation tabs

- Add sequence-to-asset linking with persistent project metadata storage

- Support one-way comment-to-marker timeline synchronization

- Add two-tab navigation (Sequences and Browse) using Spectrum buttons

- Add LinkSequenceDialog, SequencesView, and autoSyncService background engine

- Enforce Spectrum Workflow Icons and UXP layout rules

* feat(premiere-uxp): refine UI layouts, card interactions, and search box activation

* fix(premiere-uxp): set compact fixed width for file list search box

* fix(premiere-uxp): ensure search box click activation across full width in UXP

* fix(premiere-uxp): revert search box hacks and restore simple default sp-search layout

* feat(premiere-uxp): sync non-timestamped comments as markers at time 0

* feat(premiere-uxp): change link icon to unlink when asset is linked in file card

* fix(premiere-uxp): sync linked sequences between host project and browse view

* feat(premiere-uxp): remove synced markers on sequence unlink matching Frame.io

* fix(premiere-uxp): ensure reliable marker GUID capture, normalization, and fallback on unlink

* fix(premiere-uxp): use official Shumai logo for plugin manifest icons

* fix(premiere-uxp): use official PNG icons for manifest and plugin entrypoints

* refactor(premiere-uxp): use single 114x114 icon for plugin and panel

* feat(premiere-uxp): show file version in file list page file card

* build(premiere-uxp): check in built ccx package and update packaging configuration

* fix(premiere-uxp): address code review findings for media conversion, marker sync, and link scoping

- Reset hasJpegCover on project cover update and hasJpegPreview on asset media transcode
- Only advance synced comment metadata after confirmed marker transaction
- Normalize GUID keys and lookups in AutoSyncService map
- Restrict cached sequence link lookups to project-specific keys and prevent cross-project leakage on empty sequences
- Update built CCX distribution package
2026-09-17 11:51:03 +08:00
Yiling-J a6b7ac4383 Update project description in README.md 2026-09-16 10:22:13 +08:00
Yiling-J ca575803cb Update README with AI features and agent system details 2026-09-15 12:01:43 +08:00
Yiling-J def42cd000 feat(comment): add emoji reaction support for comments (#405)
* feat(comment): add emoji reaction support for comments

* fix(webui): adjust emoji picker trigger icon size to match mark-done icon

* fix(webui): prevent search icon and placeholder overlap in emoji picker

* fix(webui): use normal text color for reaction count

* feat(db): limit comment reaction code column to VarChar(32)
2026-09-14 15:01:36 +08:00
yiling ede52e5009 Release v0.4.5 2026-09-13 21:50:44 +08:00
Yiling-J ddbf897b27 feat(agent): use deterministic storage keys for preset avatars (#404) 2026-09-13 21:40:34 +08:00
Yiling-J 7d56b5bf90 feat(webui): show comments count badge in file card preview area (#403)
* feat(webui): show comments count badge in file card preview area

* perf(db): add index on asset_comments asset_id
2026-09-13 21:12:21 +08:00
Yiling-J 87e88396d1 feat(webui): add space key quick preview for files and folders (#402)
* feat(webui): add space key quick preview for files and folders

Allow users in file list views to press the Space key to quick preview the most recently selected item.

- Add FilePreviewDialog supporting both folder previews (icon, name, count) and real file previews (reusing FileViewer with viewer area and control bar).
- Constrain dialog to max 1920x1080 or 70vw/70vh.
- Support dismissing via close button, clicking outside, or pressing Space again (intercepted in capture phase).
- Enable across project file lists, share links, and public share views.

* feat(webui): auto play video in quick preview dialog

- Pass autoPlay prop from FilePreviewDialog through FileViewer to VideoViewer
- Configure videojs with autoplay: 'any' and handle policy rejection with muted autoplay fallback
- Add test coverage for autoPlay prop forwarding in FilePreviewDialog

* fix(webui): resolve video quick preview initialization and autoplay pause bugs

* fix(webui): support folder symlinks and password-protected shares in quick preview
2026-09-13 18:51:06 +08:00
Yiling-J c5b57ca862 feat(webui): add NLE comments export and migrate export API to POST (#401) 2026-09-13 16:29:58 +08:00
Yiling-J 3420d848cb feat(core): export comments to FCP, Premiere, Media Composer, and Resolve (#400)
* feat(core): export comments to FCP, Premiere, Media Composer, and Resolve

Add backend support to export video comments matching Frame.io export capabilities:
- DaVinci Resolve (.edl): CMX 3600 EDL with ResolveColorPurple markers and reply threading
- Avid Media Composer (.xml): OMFI StreamItems XML with TC1 / V1 track allocation and sequential frame positioning
- Adobe Premiere Pro (.xml): FCP7 XML sequence with dual marker placement on sequence and generatoritem
- Final Cut Pro 10.4.0+ (.fiojson): Flattened JSON schema with frame, timestamp, and annotation serialization

Includes DTO schema validation, AssetService export method, API route (GET /files/:fileId/comments/export), SMPTE drop-frame timecode calculations, unit tests, golden master tests, service integration tests, and API endpoint tests.

* test(core): move comments export test fixtures to test directory

* fix(core): escape asset name in Premiere XML, align Resolve FCM, and support CJK

- Escape XML special characters in <name> tag for Premiere Pro XML sequence
- Harmonize Resolve EDL FCM header and emitted timecodes using getEffectiveDropFrame
- Use RFC 5987 / RFC 6266 buildContentDisposition for CJK filenames in download headers
- Add test coverage for CJK filenames, comments, and author names across all 4 NLE formats

* fix(core): implement timezone-aware comment exports and sanitize resolve edl
2026-09-13 14:48:41 +08:00
yiling 70b81355c2 Release v0.4.4 2026-09-09 22:07:40 +08:00
yiling 1d552e4ae4 fix(sandbox): change initialization and hotreload log level to debug 2026-09-09 11:17:20 +08:00
Yiling-J b37b2172e7 fix(transcode): co-locate screenshots and derived artifacts in asset storage directory (#399)
* fix(transcode): co-locate screenshots and derived artifacts in asset storage directory

* refactor(transcode): centralize derived artifact directory resolution and strengthen upload assertions
2026-09-09 11:03:48 +08:00
Yiling-J 941000d277 feat(sandbox): abstract SandboxService and hot-reload allowed domains (#398)
* feat(sandbox): abstract SandboxService and hot-reload allowed domains

Introduce SandboxService with pluggable SandboxProvider in @shumai/core. Eliminate disruptive per-session sandbox resets by hot-reloading allowed domains via updateConfig, isolate violations per commandId, and eagerly initialize sandbox at worker/server boot.

* fix(sandbox): isolate command violations and serialize concurrent domain sync

Strictly isolate getBlockedHost per commandId to prevent false-positive blocked reporting on concurrent allowed commands. Serialize syncAllowedDomains to ensure concurrent requests during initialization or updates are never silently dropped. Add comprehensive unit tests for LocalSandboxProvider and concurrent bash commands.

* fix(agent): do not synchronize sandbox when allowedDomains is omitted

Make allowedDomains optional in CreateAgentSessionParams and only invoke sandboxService.syncAllowedDomains when allowedDomains is defined. Omit allowedDomains in generateSessionNameActivity so background chat title generation never overwrites the live sandbox allowlist.
2026-09-08 20:21:29 +08:00
Yiling-J 4a61e87a27 fix(agent): restrict pageCount and duration recommendations to matching media types (#397) 2026-09-08 14:52:37 +08:00
Yiling-J 04fd571bd9 feat(agent): enable read_asset tool for autofill agent (#396)
* feat(agent): enable read_asset tool for autofill agent

* fix(transcode): trigger autofill task for pdf assets

* fix(transcode): allow autofill task creation on all file assets

* fix(agent): require targetAssetId and teamId for autofill read_asset authorization

* feat(agent): instruct autofill agent to report failure directly if read_asset fails
2026-09-08 14:19:03 +08:00
Yiling-J 3a05332cd6 fix(agent): pass agent thinkingLevel to session name generation (#395) 2026-09-08 11:15:26 +08:00
yiling 51f63fc9e4 fix(agent): add error logging for failed session name generation 2026-09-08 10:47:36 +08:00
Yiling-J b35c824a27 feat(transcode): optimize video operations using ffmpeg http range requests (#393)
* feat(transcode): optimize video operations using ffmpeg http range requests

* fix(transcode): preserve non-retryable errors and ensure mapConcurrent settles on rejection
2026-09-08 10:17:15 +08:00
Yiling-J f62df9555a fix(s3): stream downloadToFile and putObject to prevent OOM on large files (#392)
* fix(s3): stream downloadToFile and putObject to prevent OOM on large files

* fix(agent): preserve file MIME detection on download_asset and align local download directory creation
2026-09-07 19:33:13 +08:00
Yiling-J 67b767f1e8 feat(upload): S3 multipart upload with offline resume and wake lock (#391)
* feat(upload): implement S3 multipart upload with offline resume and wake lock

* fix(upload): harden S3 sign and abort authorization, await confirmation, and clean up failed multipart uploads

* fix(webui): resume multipart upload on network recovery and log online event

* fix(webui): remove offline and online toast notifications
2026-09-07 16:49:00 +08:00
yiling 62e86b703e Release v0.4.3 2026-09-06 22:22:14 +08:00
Yiling-J 6c87db0581 fix(webui): clamp file card creation info to 2 lines and show tooltip on hover (#390) 2026-09-06 22:06:03 +08:00
Yiling-J bc85dc4541 docs(agents): add image and video generation settings documentation (#389) 2026-09-06 21:21:16 +08:00
Yiling-J 659a0af2c5 feat(cli): control asset deletion via SHUMAI_ALLOW_DELETE env var (#388) 2026-09-06 19:42:10 +08:00
yiling 54d2c407b5 docs(readme): add target blank to DeepWiki badge 2026-09-06 18:28:43 +08:00
yiling 8e31d05f8a docs(readme): add Ask DeepWiki badge 2026-09-06 17:32:57 +08:00
Yiling-J 8c1e59d131 feat(agent): add asset management tools and CLI commands (#387)
* feat(agent): add asset management tools and CLI commands

* fix(core): resolve code review findings for reparenting cycles, agent deniedTools update, and CLI folder delete
2026-09-06 17:15:58 +08:00
Yiling-J b087bf73ae chore(i18n): update paraglide-js to 2.25.0 and stop checking in generated code (#386)
- Upgrade @inlang/paraglide-js to 2.25.0 in root devDependencies
- Untrack 2,700+ generated paraglide files from git index
- Ignore packages/webui/paraglide in .gitignore and .dockerignore
- Remove --no-emit-git-ignore flag from i18n:compile and i18n:watch
- Chain bun run i18n:compile into build and build-npm scripts
- Add i18n compile step in Dockerfile builder stage
- Add i18n compile step in CI workflows (.github/workflows/ci.yaml, release-npm.yaml)
- Update README.md and README_CN.md with local setup instructions for i18n compilation
2026-09-06 15:48:39 +08:00
Yiling-J a49722d5c7 feat(settings): redesign image/video settings to provider dialog with model toggles (#385) 2026-09-06 15:13:01 +08:00
Yiling-J 576d8ebe64 chore(deps): upgrade bun to 1.4.2 and update packages (#384)
* chore(deps): upgrade bun to 1.4.2 and update packages

- Upgrade Bun to 1.4.2 in Dockerfile, CI workflows, and release workflows.
- Update dependencies across workspace with Bun 1.4.2.
- Preserve @earendil-works/pi-agent-core at 0.82.1.
- Retain stable compatible versions for database adapters and pdfjs-dist.
- Add explicit Buffer type annotation in transcode service.

* chore(deps): upgrade prisma to 7.10.0, pg to 8.23.0, and pdfjs-dist to 6.3.289

* chore(deps): revert dotenv-expand to 13.0.0
2026-09-06 11:31:05 +08:00
Yiling-J ffc1889cdc feat(media-generation): add gemini-omni-1.1-flash video model and redesign settings UI (#383)
* feat(settings): redesign image and video generation settings with tabs, card switch, and 2-box model selector

* fix(settings): remove model type checkmark, remove search inputs, and fix select box scrolling in add model dialog

* refactor(settings): remove display name input from add model dialog

* feat(media-generation): add gemini-omni-1.1-flash as default video model via google interactions api

* feat(media-generation): forward video parameters to gemini-omni-1.1-flash via system instructions and prompt
2026-09-06 09:42:21 +08:00
Yiling-J 6285ff8618 feat(agent): add built-in image and video generation tools and settings (#382)
* feat(agent): add built-in image and video generation tools and settings

* fix(settings): refine media generation layout and expose media tools in agent and quota forms

* feat(media-generation): add alibaba, bytedance, minimax, prodia, and azure providers

* feat(agent): support s3 key references for media generation and s3KeyOnly in read_asset
2026-09-06 09:28:53 +08:00
Yiling-J 1e60933cdb feat(agent): store preset avatars as real files in s3 storage (#381)
* feat(agent): store preset avatars as real files in s3 storage

* fix(agent): use inline base64 previews in dialog and remove static avatar files

* feat(agent): add 4 avatar presets and track avatarPreset in agent config

* refactor(agent): consolidate preset avatar base64 data in dtos
2026-09-04 16:39:19 +08:00
Yiling-J dd0ea05a88 feat(asset): record and display agent provenance on assets and audit logs (#380)
* feat(asset): record and display agent provenance on assets and audit logs

* style(webui): apply 30% translucent frosted glass background to bot badges

* style(webui): match bot icon badge style to thumbnail media overlay (bg-black/60 text-white)

* style(webui): use "AI" text badge with pdf overlay style instead of bot icon
2026-09-04 11:27:52 +08:00
yiling 52330869a2 Release v0.4.2 2026-09-03 21:49:37 +08:00
Yiling-J 0c561e9b39 refactor(webui): use semantic system colors in notification settings (#379) 2026-09-03 21:36:28 +08:00
Yiling-J a236cd3a97 feat(provider): add provider and model sync feature with vendored generator (#378)
* feat(provider): vendor and adapt pi model generator

- Vendor generate-models.ts, model-data.ts, and models-dev-reasoning-options.ts from @earendil-works/pi tag v0.82.1
- Adapt imports to use @earendil-works/pi-ai and expose generateModels programmatic function
- Add compare.test.ts to verify vendored generator against original built-in catalog
- Add packages/core/src/provider/generator to eslint ignores

* feat(provider): add provider and model sync api and ui

* feat(webui): add checkbox for existing providers and clean dialog description

* feat(webui): add expand all and collapse all to sync providers dialog

* refactor(provider): remove compare.test.ts and cli overhead from generate-models

* fix(provider): add 30s timeout and strict error handling to sync catalog fetching

* fix(e2e): eliminate drag-and-drop race condition on webkit

Allow requestAnimationFrame collision updates to settle in dragCard helper before releasing pointer, and scope fileCard locator via data-testid to avoid matching sidebar tree items.
2026-09-03 21:01:14 +08:00
Yiling-J c3ef769f51 feat(provider): optimize provider and model configuration management (#377)
* feat(provider): optimize provider and model configuration management

* style(provider): use default tabs variant in provider settings dialog

* style(provider): make tabs list full width

* feat(provider): make model card row clickable and remove pencil edit icon

* feat(settings): persist active settings tab in url hash

* feat(agent): add search box and alphabetical sorting for provider and model selectors

* refactor(providers): remove frontend pagination and display all models in scrollable list

* fix(providers): address code review findings for model editing, i18n, and api protocol propagation
2026-09-03 15:16:16 +08:00
Yiling-J e58dfaa71a feat(agent): consolidate media tools into read_asset and add S3 key support to download_asset (#376)
* feat(agent): consolidate media tools into read_asset and add S3 key support to download_asset

* fix(agent): refine parameter descriptions and remove download URL from read_asset text content

* fix(agent): resolve owning asset and enforce RBAC permissions when downloading by S3 key
2026-09-02 21:51:07 +08:00
Yiling-J 35b57cc0ab feat(agent): support dynamic annotationId resolution across chat and comments (#375)
* feat(agent): improve timestamp precision and proxy selection for video screenshots

* feat(agent): support dynamic annotationId resolution across chat and comments

* fix(agent): scope annotation resolution to asset and format has_markup consistently
2026-09-02 15:17:56 +08:00
Yiling-J 5a754bcb94 feat(agent): improve timestamp precision and proxy selection for video screenshots (#374) 2026-09-01 21:15:28 +08:00
Yiling-J 64b68e7d63 feat(agent): move thread metadata to structured context XML (#373)
* feat(agent): move thread metadata to structured context XML

* feat(core): dynamically inject thread metadata in getSessionEntries
2026-09-01 17:42:56 +08:00
Yiling-J c2f477a391 fix(agent): hide main comment sessions in dashboard sessions list (#372)
* fix(agent): hide main comment sessions in dashboard sessions list

* feat(webui): auto mention comment creator when replying
2026-09-01 16:20:58 +08:00
Yiling-J 9263971653 更新 README_CN.md 以包含 Docker Compose 部署指南
添加了使用 Docker Compose 部署 Shumai 的详细说明和提示词。
2026-09-01 10:25:57 +08:00
Yiling-J 79a479c87c fix(webui): strip styles and preserve multiline text on paste in chat input (#371)
* fix(webui): strip styles and preserve multiline text on paste in chat input

* fix(db): remove custom log wait strategy in test global setup to prevent postgres startup race condition
2026-08-31 21:29:00 +08:00
Yiling-J 134eb8b7fa fix(agent): set empty details in asset tool results to avoid data duplication (#370) 2026-08-31 20:43:05 +08:00
Yiling-J e06478df88 feat(chat): support markups, attachments, and timestamps in agent 1-to-1 chat (#368)
* feat(chat): support markups, attachments, and timestamps in agent 1-to-1 chat

* feat(chat): improve message card layout with inline badges and integrated assets

* fix(chat): enable image attachment thumbnails in 1-to-1 chat cards

* fix(chat): address code review feedback on input state, mentions, i18n, and session deletion

* fix(chat): replace ring with border color on selected message card
2026-08-31 20:11:27 +08:00
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
yiling 4b62c31f29 Release v0.4.0 2026-08-28 20:40:33 +08:00
Yiling-J 2208d4e0e0 fix(webui): align mobile comment cards and thread vertical indicator (#361) 2026-08-28 20:26:26 +08:00
Yiling-J df7f4c3c2d Update README_CN with project management details
Added information about project management and media handling in Shumai.
2026-08-28 20:25:46 +08:00
Yiling-J 12323e1416 Enhance README with project management and media details
Added information about project management features and media processing in Shumai.
2026-08-28 20:23:38 +08:00
yiling 2edc5e1071 fix(e2e): enable ryuk container reaper for app e2e tests 2026-08-28 16:22:29 +08:00
Yiling-J 2162ed9ebe fix(webui): fix breadcrumb file dropdown trigger stretching and alignment (#360) 2026-08-28 16:07:27 +08:00
Yiling-J 6acebb73ec feat(webui): add mobile friendly file detail and public share view (#359)
* feat(webui): add mobile friendly file detail and public share view

* fix(webui): address review feedback for mobile file detail and public share view

* fix(webui): use dynamic viewport and flex column layout for mobile file viewer

* fix(webui): support iOS WebKit video fullscreen and guard requestFullscreen

* fix(webui): compact page indicator and layout in mobile PDF control bar
2026-08-28 15:11:33 +08:00
EICCIO Advisors 7a1d6c0ab5 docs: add SECURITY.md with a private disclosure path (#357)
The project has no security policy, so a researcher with a finding today has
only a public issue or Discord, both of which disclose before a fix exists.

Routes reports to GitHub private vulnerability reporting. Names deployment
manifests as in scope, since the documented quickstart is what most operators
actually run. Adds operator guidance for the three things a self-hoster owns:
the session secret, not publishing the database port, and treating the agent
as a code-execution surface.

Response timelines are left for the maintainer to set.
2026-08-28 09:21:21 +08:00
Yiling-J d16e31c0e5 feat(webui): add simplified mobile-friendly layout for file and share lists (#356)
* feat(webui): add simplified mobile-friendly layout for file and share lists

* refactor(webui): switch mobile file list layout to 1-column grid

* feat(webui): show foldertree by default in child sidebar and add close button

* feat(webui): add collapsible section headers and fix folder card full-width on mobile

* feat(webui): improve mobile breadcrumb bar with middle truncation and dual ellipsis

* fix(webui): unify breadcrumb DOM structure across desktop and mobile

* fix(webui): remove unused breadcrumbs variable in BreadcrumbNav

* fix(webui): complete and confirm file uploads on mobile and handle errors properly

* fix(webui): remove active scale animation on mobile FAB to stabilize dropdown menu anchor

* refactor(webui): use PresignedUrl type from dtos for uploadFiles and eliminate any cast

* fix(webui): scope folder card max width to desktop with responsive md:max-w-[340px]
2026-08-27 20:44:08 +08:00
Yiling-J d9a8b6a191 feat(webui): truncate long file names with 100ms hover tooltip (#355) 2026-08-27 10:54:35 +08:00
yiling 5ec4cd7fcd docs: update documentation link in README and README_CN 2026-08-26 21:44:50 +08:00
Yiling-J a7925e3c79 fix(share): hide and soft-delete symlinks when target assets are trashed (#354) 2026-08-26 21:04:38 +08:00
Yiling-J 472b420620 fix(transcode): apply team hardware acceleration and source bitrate capping to watermark transcoding (#353) 2026-08-26 17:00:11 +08:00
Yiling-J 8f55ba1d37 feat(transcode): add hardware-accelerated video transcoding support (#352)
* feat(transcode): add hardware-accelerated video transcoding support

* feat(transcode): use encoder quality modes and source-capped maxrate for video transcode

* fix(transcode): scale max bitrate for downsampled preview framerates

* fix(transcode): propagate videoBitRate in getMediaInfoActivity and update auto description
2026-08-26 16:28:14 +08:00
yiling 7b1428bf51 Release v0.3.11 2026-08-25 22:05:47 +08:00
yiling d5b3b1868e fix(webui): reload video player and reset state when switching videos in viewer 2026-08-25 21:52:15 +08:00
yiling 49f3fc0be5 fix(webui): restore full width bottom bar spanning across carousel in file viewer 2026-08-25 21:27:20 +08:00
Yiling-J 59e641ccb3 fix(webui): prevent left carousel remounting and scroll jump on file selection (#351) 2026-08-25 21:01:51 +08:00
Yiling-J 1d9268b224 feat(project): add recent viewed files section to project folder tree (#348)
* feat(project): add recent viewed files section to project folder tree

* feat(webui): disable toolbar buttons and context menu in recents page

* test(core): optimize recents cap test execution time

* feat(webui): show hint text in recents page top toolbar

* feat(webui): rename recents section to Recently Viewed

* refactor(core): consolidate recents methods into AssetService

* fix(api): forward pagination parameters in folder children endpoint (#349)

* fix(project-recents): scope views and disable recents mutations

* fix(api): allow recent views in demo mode

* fix(api): limit demo recent view exception to post
2026-08-25 18:51:24 +08:00
Yiling-J 470a4bd6f7 feat(auth): add admin password reset CLI command and reset password web UI (#347)
* feat(auth): add admin password reset CLI command and reset password web UI

* fix(auth): invalidate previous reset tokens and use AsyncLocalStorage for link capture
2026-08-25 14:35:33 +08:00
yiling 8801d59b2e docs: symlink CLAUDE.md to AGENTS.md 2026-08-25 09:50:54 +08:00
yiling 6a20e06982 Release v0.3.10 2026-08-23 21:19:45 +08:00
Yiling-J b17abce2c2 fix(kanban): improve drag-drop to column bottom, remove empty drop line, and fix timeline alignment (#346) 2026-08-23 21:11:33 +08:00
Yiling-J f67e334016 feat(kanban): update task status permissions, reporter defaults, and participant access (#345)
* feat(kanban): allow editors to change task status and default reporter to creator

* fix(kanban): hide create task button for reviewers and eliminate duplicate error toast
2026-08-23 20:38:56 +08:00
yiling c1de66520e update readme image 2026-08-23 16:53:44 +08:00
Yiling-J 37e086d822 fix(webui): sidebar selection styling, kanban active state, pointer cursors, and owner dashboard (#344)
* fix(webui): update sidebar selection styling, kanban active state, and pointer cursors

* feat(webui): move dashboard to left sidebar and prevent mount animation

* fix(e2e): update create-project test to click Home button in sidebar
2026-08-23 16:39:56 +08:00
Yiling-J d21f8ca8de fix(kanban): use true thumbnail and poster for task asset previews (#343) 2026-08-23 14:36:46 +08:00
Yiling-J 6af4e7c2ec feat(kanban): resolve latest version for linked version stack assets and update demo login text (#342) 2026-08-23 11:19:48 +08:00
Yiling-J 1f2bdc8c9e feat(agentic kanban): phase 1 not-agentic kanban board (#330)
* feat(kanban): implement AI-native kanban database models, services, and REST APIs

* feat(webui): implement team kanban board and task management

* style(webui): increase kanban dialog widths and form container

* fix(webui): ensure kanban dialogs override sm:max-w-lg base class

* style(webui): set edit task dialog max width to 5xl

* chore: untrack kanban plan markdown files

* feat(webui): update kanban page layout to 2 columns and refine task activity UI

* fix(webui): constrain kanban column and board heights for vertical scrolling

* feat(kanban): unify task status transition into updateTask API and allow unconstrained human task transitions

* fix(webui): add optimistic updates to kanban drag-and-drop to eliminate flash

* refactor(webui): remove client-side search box from kanban header

* feat(kanban): redesign task dialog comments area and add attachment support

* refactor(webui): remove top status action bar from task info dialog

* fix(webui): narrow query cache predicate and add defensive guards for kanban drag optimistic update

* feat(kanban): add drag-and-drop task reordering with fractional indexing (#331)

* feat(kanban): add drag-and-drop task reordering with fractional indexing

* fix(kanban): improve card drop zones, snap indicators, and column highlight

* fix(kanban): enable card droppables only during active drag

* fix(kanban): refine hover styles and drop indicators for column boundaries

* fix(kanban): unify bottom drop indicator and fix top indicator clipping

* fix(kanban): ensure full column highlight and full coverage drop target

* minor change

* feat(kanban): allow agent tasks free drag-and-drop and enforce status change permissions (#332)

* refactor(kanban): rename task_type_agentic translation keys to task_type_agent

* feat(kanban): refactor task type enum to isAgentTask boolean (#333)

* refactor(kanban): remove phase 2 agent execution logic and streamline phase 1 kanban

* feat(kanban): add notifications and audit logging for kanban (#334)

* feat(kanban): redesign config area layout and add parent tasks multi-selector (#335)

* feat(webui): redesign kanban task dialog config area

* feat(kanban): simplify task dependencies with parent tasks multi-selector

* refactor(kanban): remove unused links routes and legacy dependency methods

* feat(kanban): connect assets and kanban tasks with many-to-many relationship (#336)

* feat(kanban): connect assets and kanban tasks with many-to-many relationship

* feat(kanban): improve asset picker layout, infinite scrolling, and breadcrumb icon styling

* fix(kanban): ensure asset picker scrollarea is scrollable with min-h-0 and shrink-0 flex styling

* fix(kanban): hide recently deleted in folder tree picker and adjust header padding

* fix(kanban): use lucide files icon instead of paperclip for linked assets

* feat(kanban): improve task deletion, goal sidebar interaction, and card styling (#337)

* feat(kanban): improve task deletion, goal sidebar interaction, and card styling

* feat(kanban): move agent task badge after priority and update to orange style

* feat(kanban): add status Compare-And-Swap (CAS) to prevent drag-and-drop race conditions (#338)

* feat(kanban): add status Compare-And-Swap (CAS) to prevent drag-and-drop race conditions

* style(kanban): rotate kanban icon 180 degrees in sidebar and top nav

* style(kanban): remove rotate-180 from SquareKanban icons

* feat(kanban): add unassigned goal record and fix all tasks count (#339)

* feat(kanban): add unassigned goal record and fix all tasks count

* feat(kanban): toggle task count with three-dot action button on goal card hover

* fix(ci): pin bun version to 1.3.14 across CI and Docker (#340)

* fix(webui): truncate goal name to max 2 lines in kanban sidebar (#341)
2026-08-23 10:28:56 +08:00
yiling 4c0fd29b7f Release v0.3.9 2026-08-18 18:42:59 +08:00
Yiling-J ffef67be8f feat(quota): move usage monitoring to team dashboard (#327) 2026-08-18 15:57:36 +08:00
Yiling-J 4d100bf542 docs(team-settings): add resource quotas documentation and update readme features (#326)
* docs(team-settings): add resource quotas documentation and update readme features

* fix(webui): correct sandbox filesystem description
2026-08-18 14:48:12 +08:00
Yiling-J 8a75d015a1 fix(quota): exclude agents from quota rules and usage records (#325)
* fix(quota): exclude agents from quota rules and usage records

* refactor(quota): remove agent_skill_call_count resource type and related logic

* chore(db): replace manual migration with prisma-generated migration
2026-08-18 11:56:03 +08:00
Yiling-J f806272c06 feat(settings): reorganize settings into personal, team, and AI sections (#324) 2026-08-18 08:35:23 +08:00
Yiling-J 4935eeff28 fix(webui): preserve selected chatbot agent preference on reload (#323) 2026-08-17 20:47:57 +08:00
Yiling-J eed0264b9c feat(quota): add 2-level database-backed resource quota system (#318)
* feat(quota): add database-backed resource quota system

* feat(webui): add resource quota management in team settings (#319)

* feat(webui): add resource quota settings in team management

* refactor(webui): update quotas list to full row layout and restrict skill/mcp to select list

* feat(quota): refactor quota system to 2-level rules and records

* fix(webui): fix overflow and scroll area in quota usage records dialog

* fix(webui): ensure quota records scroll area has explicit max height

* feat(webui): improve quota cards interaction and restrict editable fields in edit mode

* fix(quota): serialize initial records, validate merged updates, and reset on dimension changes (#320)

* feat(quota): replace network quota with agent tools quota (#321)

* feat(webui): show remaining time until next refresh in quota usage records

* fix(webui): rename bash quota resource to Agent Bash Calls

* refactor(quota): remove unused reserved field from quota records

* refactor(quota): remove quota rule cache (#322)
2026-08-17 20:24:05 +08:00
Yiling-J dd82daf65c feat(webui): use project members for asset comment mentions (#315)
* feat(webui): use project members for asset comment mentions

* refactor(project): remove legacy unused bots endpoint and props
2026-08-16 16:44:50 +08:00
Yiling-J 55d9596835 feat(authz): enforce project-aware roles for agent/skill/mcp permissions (#314)
* feat(authz): enforce project-aware roles for agent/skill/mcp permissions

Introduce a shared resolveEffectiveRole helper that mirrors AuthzService
precedence rules (projectMember.role override -> team role for team-scoped
members -> restricted), and route all agent/skill/mcp runtime permission
checks through it. Previously these checks used the raw teamMember.role,
which let project-only members execute team-level agents/skills/MCP tools
and ignored per-project role overrides.

Changes:
- authz: add resolveEffectiveRole(teamId, projectId, userId, db) and
  refactor hasPermission to use it (behavior-preserving)
- chat/asset/agent-activity: gate agent usage by the effective project role
- read_skill: enforce skill permission via effective role (projectId
  threaded from the agent session)
- mcp-service: checkPermission and buildAgentTools filter by effective
  role; un-permitted servers' tools are no longer advertised to the model
- agent activity: only advertise skills the user's effective role permits
- listProjectMembers: filter included agent bots by the requester's
  effective project role
- new GET /projects/:projectId/chat-agents API returning chat agents
  scoped to the project and the user's effective role; WebUI chat selector
  now uses it (settings keeps the team-level API)
- tests: effective-role resolver, chat/mention/MCP/skill project-role
  matrices, listProjectChatAgents, listProjectMembers filter, API route

* fix(agent): forward projectId to getAgentChatContextActivity in agentChat workflow

The agentChat workflow called getAgentChatContextActivity without passing
projectId from the task payload, so project-scoped members (scope:
'project') resolved a null effective role in the activity and were denied
with 'Insufficient role to use agent' even though the chat selector and
chat.ts both authorized them. Forward payload.projectId so the activity
enforces the user's effective project role, and assert the forwarding in
the workflow unit test (fails without the fix).
2026-08-16 15:44:45 +08:00
Yiling-J cb1c1c502b feat(agent): add permission controls for chat agents (#313)
* feat(agent): add permission controls for chat agents

* refactor(agent): extract shared agent permission helpers

Consolidate the duplicated role-hierarchy logic into
packages/core/src/agent/permissions.ts:

- getRoleLevel(): numeric level for a team role (fail closed at 0)
- getAgentRequiredLevel(): required level for an agent permission
  (defaults to reviewer/1)
- getAllowedAgentRoles(): inclusive role set for filtering

The typed Record over TeamMemberRole makes the mapping exhaustive,
so adding a new role fails compilation until all sites are updated.
Used by ChatService.startOrContinueChat, AssetService comment
mentions, getAgentChatContextActivity, AgentService.listAgents, and
TeamService.getTeamMembers, replacing four inline copies of the
hierarchy and the allowed-roles conditionals.

Also fix the API permission-denial test to mock HTTPException(403)
and assert a 403 response instead of a generic Error/500, matching
real authzService behavior.

* test(agent): fix flaky comment DAG tests by spacing ULID id generation

ULID ids have 1ms timestamp granularity; back-to-back comment creates
frequently land in the same millisecond, in which case Prisma ULIDs sort
by their random suffix instead of creation order. The DAG spine in
initializeAgentSessionActivity chains top-level comments by id, so a
shuffled order produces paths that omit preceding comments, making the
path-to-root assertions flaky (~80% of full-file runs locally).

Add a 2ms sleep between consecutive comment creates in the affected
tests, guaranteeing strictly increasing ULID timestamps. A 2ms delay is
sufficient because the next create always fires at least 2ms after the
previous ULID was generated. Production is unaffected: real comments
arrive seconds apart via separate requests.
2026-08-16 11:16:14 +08:00
2524 changed files with 117587 additions and 72430 deletions
+2 -1
View File
@@ -14,4 +14,5 @@ helm-charts
.env
.editorconfig
.idea
coverage*
coverage*
packages/webui/paraglide
+17 -8
View File
@@ -22,9 +22,9 @@ jobs:
uses: actions/checkout@v4
- name: Setup Bun
uses: oven-sh/setup-bun@v1
uses: oven-sh/setup-bun@v2
with:
bun-version: latest
bun-version: 1.4.2
- name: Install dependencies
run: bun install
@@ -34,6 +34,9 @@ jobs:
sudo apt-get update
sudo apt-get install -y ripgrep bubblewrap socat ffmpeg poppler-utils imagemagick
- name: Compile i18n
run: bun run i18n:compile
- name: Lint
run: bun run lint
@@ -76,13 +79,16 @@ jobs:
uses: actions/checkout@v4
- name: Setup Bun
uses: oven-sh/setup-bun@v1
uses: oven-sh/setup-bun@v2
with:
bun-version: latest
bun-version: 1.4.2
- name: Install dependencies
run: bun install
- name: Compile i18n
run: bun run i18n:compile
- name: Install Playwright browser (${{ matrix.project }})
run: bunx playwright install --with-deps ${{ matrix.project }}
@@ -118,9 +124,9 @@ jobs:
uses: actions/checkout@v4
- name: Setup Bun
uses: oven-sh/setup-bun@v1
uses: oven-sh/setup-bun@v2
with:
bun-version: latest
bun-version: 1.4.2
- name: Install dependencies
run: bun install
@@ -130,6 +136,9 @@ jobs:
sudo apt-get update
sudo apt-get install -y ripgrep bubblewrap socat ffmpeg poppler-utils imagemagick
- name: Compile i18n
run: bun run i18n:compile
- name: Install Playwright browser (${{ matrix.project }})
run: bunx playwright install --with-deps ${{ matrix.project }}
@@ -152,9 +161,9 @@ jobs:
uses: actions/checkout@v4
- name: Setup Bun
uses: oven-sh/setup-bun@v1
uses: oven-sh/setup-bun@v2
with:
bun-version: latest
bun-version: 1.4.2
- name: Install dependencies
run: bun install
+4 -1
View File
@@ -36,7 +36,7 @@ jobs:
- name: Setup Bun
uses: oven-sh/setup-bun@v2
with:
bun-version: latest
bun-version: 1.4.2
- name: Setup Node.js
uses: actions/setup-node@v6
@@ -53,6 +53,9 @@ jobs:
- name: Install dependencies
run: bun install
- name: Compile i18n
run: bun run i18n:compile
- name: Lint
run: bun run lint
+7
View File
@@ -2,6 +2,8 @@ node_modules
.bun
dist
out
*.ccx
!apps/premiere-uxp/shumai-premiere.ccx
.DS_Store
*.log
.env
@@ -11,6 +13,7 @@ data/
*.db
*.diff
*.orig
code_quality.md
.agents
# Playwright
@@ -18,3 +21,7 @@ data/
/test-results/
/blob-report/
/playwright/.cache/
# Paraglide JS
packages/webui/paraglide
Symlink
+1
View File
@@ -0,0 +1 @@
AGENTS.md
+10 -2
View File
@@ -1,6 +1,6 @@
#syntax=docker/dockerfile:1.7-labs
# Stage 1: Builder
FROM oven/bun:1 AS builder
FROM oven/bun:1.4.2 AS builder
WORKDIR /app
@@ -18,6 +18,9 @@ RUN ls -la packages/transcode/node_modules
# Copy source code
COPY . .
# Compile i18n
RUN bun run i18n:compile
# Build API and Worker
RUN bun run build.ts
@@ -25,7 +28,7 @@ RUN bun run build.ts
RUN bun run scripts/extract-runtime-deps.ts
# Stage 2: Runner
FROM oven/bun:1 AS runner
FROM oven/bun:1.4.2 AS runner
# Install ffmpeg/ffprobe
COPY --from=mwader/static-ffmpeg:8.1 /ffmpeg /usr/local/bin/
@@ -80,6 +83,11 @@ USER root
COPY scripts/docker-entrypoint.sh /usr/local/bin/docker-entrypoint.sh
RUN chmod +x /usr/local/bin/docker-entrypoint.sh
# Expose "bun index.js" as "shumai" CLI command (and alias "shuami")
RUN printf '#!/bin/sh\nexec bun /app/index.js "$@"\n' > /usr/local/bin/shumai \
&& chmod +x /usr/local/bin/shumai \
&& ln -s /usr/local/bin/shumai /usr/local/bin/shuami
ENTRYPOINT ["docker-entrypoint.sh"]
# Default command: run migrations and start API server
+27 -4
View File
@@ -5,11 +5,18 @@
<h1 align="center">Shumai</h1>
<p align="center">
<strong>An open-source platform for all your creative work.</strong>
<strong>The best open-source Frame.io alternative for all your creative work.</strong>
</p>
<p align="center">
<a target="_blank" href="https://shumai.one/">Website</a> | <a target="_blank" href="https://docs.shumai.one/introduction">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>
<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>
<a target="_blank" href="https://deepwiki.com/shumaiOne/shumai"><img alt="Ask DeepWiki" src="https://deepwiki.com/badge.svg" /></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>
![Shumai App Screenshot](docs/screenshot.webp)
@@ -27,9 +34,12 @@ Shumai is an open-source Frame.io alternative built for creative teams to collab
* **Share Link Watermarking**: Protect shared media with customizable text and image watermarks, and save watermark as reusable templates.
* **Wide File Format Support**: Preview common creative file formats, including images (with PSD support), videos, audio, and documents, while allowing any file type to be uploaded and stored.
* **Office & Document PDF Proxying via Gotenberg**: Convert Word, PowerPoint, Excel, Markdown, HTML, and CSV documents to high-quality PDF proxies for in-browser previewing using [Gotenberg](https://docs.shumai.one/using-shumai/gotenberg).
* **NLE Export & Premiere Pro Plugin (Experimental)**: Export timestamped review comments to your favorite non-linear editor (Premiere Pro XML, DaVinci Resolve EDL, Final Cut Pro, Avid Media Composer) or use the experimental Premiere Pro UXP plugin to import media assets and auto-sync comments directly to sequence timeline markers. See [documentation](https://docs.shumai.one/using-shumai/nle-and-premiere).
But Shumai goes beyond being a Frame.io alternative. With modern models like GPT-Image-2 and Seedance 2.5, AI can already handle a surprising amount of creative work. That means you can create or update videos and images from a simple prompt without having to jump back into Photoshop, Premiere or Houdini. That is why Shumai includes a powerful agent system:
> **AI is optional.** You can use Shumai as a traditional Frame.io alternative and completely ignore the AI features if they aren't useful for your team.
* **Agent as a Team Member**: Mention a context-aware AI agent with `@mentions` directly in asset comments, just like a real teammate.
* **Agent as a One-to-One Assistant**: Chat privately with the agent and ask it to help with tasks.
* **Custom Skills & Tools**: Extend the agent by registering custom scripts, tools, and automation skills.
@@ -37,6 +47,7 @@ But Shumai goes beyond being a Frame.io alternative. With modern models like GPT
* **Isolated Sandbox Execution**: Run agent-submitted scripts safely in a sandboxed environment.
* **AI Metadata Autofill**: Automatically fill in custom metadata for new assets.
* **Semantic Search**: Find assets by visual or conceptual meaning using vector embeddings (Gemini Embedding 2).
* **Resource Quotas**: Set usage limits on AI tokens, costs, and tool execution per member, role, or team-wide, with real-time tracking.
Here is a short demo video showing what the Shumai agent can do:
@@ -44,6 +55,12 @@ Here is a short demo video showing what the Shumai agent can do:
https://github.com/user-attachments/assets/1186067a-72c0-41b9-836f-987438f2332a
Shumai also brings project management into the creative workflow. A built-in Kanban board helps teams organize tasks, track progress, and collaborate in one place.
The ultimate goal is an **agentic Kanban**, where agents and team members can work together on tasks. This is still a **work in progress**: you can already create tasks for AI agents, but agents cannot act on those tasks yet.
<img width="2880" height="2160" alt="localhost_3000_teams_01M0HQR3EEBS0B46K4FK39X2C8_kanban(1080p-2) (1)" src="https://github.com/user-attachments/assets/cd0648d0-c69a-4398-958b-8d15a33378b0" />
> [!NOTE]
@@ -301,11 +318,17 @@ To set up Shumai locally for development:
```
2. Start the `pgvector` database container (as described in **Option 2, Step 1**).
3. Create a `.env` file at the root of the workspace using the configuration from **Option 2, Step 5**.
4. Apply the database schema migrations:
4. Generate i18n translation files:
```bash
bun run i18n:compile
```
> [!TIP]
> During frontend development, you can run `bun run i18n:watch` in a separate terminal to automatically recompile translation files whenever you edit strings in `packages/webui/messages/`.
5. Apply the database schema migrations:
```bash
bun run db:migrate
```
5. Start the local development server:
6. Start the local development server:
```bash
bun run dev
```
+43 -7
View File
@@ -9,8 +9,14 @@
</p>
<p align="center">
<a target="_blank" href="https://shumai.one/">官方网站</a> | <a target="_blank" href="https://docs.shumai.one/introduction">文档</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>
<a target="_blank" href="https://deepwiki.com/shumaiOne/shumai"><img alt="Ask DeepWiki" src="https://deepwiki.com/badge.svg" /></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)
@@ -28,6 +34,7 @@ Shumai 是一个开源的 Frame.io 替代方案,专为创意团队打造,让
* **分享链接水印**:通过可自定义的文字和图片水印保护共享媒体,并将水印配置保存为模板以便重复使用。
* **丰富的文件格式支持**:支持预览常见创意文件格式,包括图片(支持 PSD)、视频、音频和文档,同时可上传和存储任意类型的文件。
* **基于 Gotenberg 的文档 PDF 转码代理**:通过集成 [Gotenberg](https://docs.shumai.one/using-shumai/gotenberg) 支持将 Word、PowerPoint、Excel、Markdown、HTML 和 CSV 文档高质量转换为 PDF 代理文件进行在线预览。
* **非编剪辑导出与 Premiere 插件(实验性)**:支持将时间戳审阅评论导出至常用非编软件(Premiere Pro XML、DaVinci Resolve EDL、Final Cut Pro、Avid Media Composer),或使用实验性的 Premiere Pro 原生 UXP 插件导入媒体素材并将评论自动同步为时间轴标记。详见[相关文档](https://docs.shumai.one/using-shumai/nle-and-premiere)。
但 Shumai 不仅仅只满足于 Frame.io 的开源替代。随着 GPT-Image-2、Seedance 2.5 这类强大模型的问世,AI已经生成产品级的图片/视频。很多时候,你只要给一句提示词,就能直接生成或修改图片和视频,而不用再打开 Photoshop、Premiere 或者 Houdini。也正因为这样,Shumai 才把 AI Agent 做成了核心能力:
@@ -38,11 +45,19 @@ Shumai 是一个开源的 Frame.io 替代方案,专为创意团队打造,让
* **沙箱隔离执行**:Agent 生成的脚本会在隔离环境里运行,更安全。
* **AI 自动补全元数据**:新素材上传后,系统可以自动帮你补一些元数据。
* **语义搜索**:支持按画面内容或语义找素材,底层用的是向量 embedding(Gemini Embedding 2)。
* **资源配额**:支持按成员、角色或全团队对 AI Token、成本和工具调用设置使用上限与实时用量监控。
下面是一个简短的 demo 视频,展示了 Shumai Agent 能做什么:
https://github.com/user-attachments/assets/1186067a-72c0-41b9-836f-987438f2332a
Shumai 也将项目管理融入了创意工作流程。 内置的看板可以帮助团队整理任务以及跟踪进度。
最终目标是打造一个 Agentic看板,让 Agent 和团队成员能够围绕同一个目标协同工作。目前这一功能仍在开发中: 你已经可以在看板中为 Agent 创建任务,但 Agent 目前还无法自动执行这些任务。
<img width="2880" height="2160" alt="localhost_3000_teams_01M0HQR3EEBS0B46K4FK39X2C8_kanban(1080p-2) (1)" src="https://github.com/user-attachments/assets/29ff1db1-2d65-4e3c-b467-754b777b406f" />
> [!NOTE]
> **媒体处理与存储机制:** 上传媒体文件后,Shumai 始终会保留并存储原始文件。请注意,系统中显示的文件大小为原始文件的大小,不包含转码后生成的代理文件大小。无论图片还是视频,都会额外生成一张 300p 的 WebP 封面图,作为文件列表中的预览图。此外:
>
@@ -56,6 +71,24 @@ https://github.com/user-attachments/assets/1186067a-72c0-41b9-836f-987438f2332a
以下是使用本地存储运行 Shumai 的快速上手指南。如需了解高级配置(包括 S3 兼容存储配置、Temporal 工作流编排等),请参阅我们的[官方文档](https://docs.shumai.one/getting-started/overview)。
### 方案一:使用 Docker Compose(推荐)
<details>
<summary>复制这个提示词,让agent帮你安装</summary>
```
请帮我在本机使用 Docker Compose 一键部署 Shumai。
请严格参考官方文档:
https://gh-proxy.com/https://raw.githubusercontent.com/shumaiOne/shumai/main/README_CN.md
要求:
1. 只能使用 Docker Compose local方式部署,不要使用其他部署方式。
2. 部署前请先检查本机是否已安装并可正常使用 Docker 和 Docker Compose。
3. 如果本机未安装 Docker,请立即提醒用户先安装 Docker,并停止后续部署操作。不要自行安装 Docker,也不要采用其他方式部署。
4. 获取 `docker-compose-aliyun.yaml` 文件内容时,必须通过 `https://gh-proxy.com` 加速访问,不要直接访问 GitHub Raw 地址。
```
</details>
使用 Docker Compose 是运行 Shumai 最快的方式。您无需克隆仓库,也不需要手动安装依赖包。请确保电脑上已安装 [Docker](https://docs.docker.com/get-docker/) 和 [Docker Compose](https://docs.docker.com/compose/install/),然后按照以下步骤操作:
@@ -326,17 +359,20 @@ bun install
2. 启动 `pgvector` 数据库容器(参考**方案二中的第一步**)。
3. 参照**方案二中的第五步**,在项目根目录下创建一个 `.env` 文件。
4. 执行数据库结构迁移:
4. 生成多语言国际化(i18n)代码:
```bash
bun run i18n:compile
```
> [!TIP]
> 在前端开发过程中,可以在单独的终端窗口中运行 `bun run i18n:watch`,在修改 `packages/webui/messages/` 下的翻译文案时自动重新编译。
5. 执行数据库结构迁移:
```bash
bun run db:migrate
```
5. 启动本地开发服务器:
6. 启动本地开发服务器:
```bash
bun run dev
```
+58
View File
@@ -0,0 +1,58 @@
# Security Policy
## Reporting a Vulnerability
Please report security vulnerabilities **privately**. Do not open a public issue,
pull request or Discord message for a suspected vulnerability, as that discloses it
to everyone before a fix exists.
Use **[GitHub private vulnerability reporting](https://github.com/shumaiOne/shumai/security/advisories/new)**
(the "Report a vulnerability" button on the Security tab). If that is unavailable,
contact the maintainer directly rather than in a public channel.
Please include:
- What the issue is, and the impact you believe it has
- The version or commit you tested (`git rev-parse HEAD`, or the image digest)
- Steps to reproduce, ideally minimal
- Your deployment shape: storage backend, whether the agent feature is enabled,
and whether the instance is internet-reachable
## Supported Versions
Shumai is pre-1.0 and moves quickly. Security fixes are made against the **latest
release**. Users are encouraged to track releases rather than pin indefinitely.
## Scope
**In scope** — the application, its API, the shipped Docker images, and the
deployment manifests under `docker-compose/`.
Deployment manifests are explicitly in scope. A default that is unsafe when
followed as documented is a real finding, because the documented quickstart is what
most operators actually run.
**Out of scope**
- Vulnerabilities in third-party dependencies, unless Shumai's use of them is what
creates the exposure. Report those upstream.
- Findings that require an already-compromised host or database.
- Configurations that deviate from the documented deployment.
## Operator guidance
Shumai is self-hosted, so several controls belong to the operator rather than to the
project:
- **Set `BETTER_AUTH_SECRET` per deployment.** It signs sessions and, in local
storage mode, upload URLs. Never reuse a value from documentation or an example.
- **Do not expose the instance to the public internet without a reverse proxy**
terminating TLS and applying your own access policy.
- **Do not publish the database port.** Set a real database password.
- **Treat the agent feature as a code-execution surface.** If you enable it, run it
where a compromise is survivable, and review the sandbox network policy.
## Disclosure
Please allow a reasonable period for a fix before public disclosure. The maintainer
will acknowledge reports and keep reporters informed of progress.
+1 -1
View File
@@ -1,6 +1,6 @@
{
"name": "@shumai/agent-app",
"version": "0.3.8",
"version": "0.4.6",
"private": true,
"type": "module",
"bin": {
+4
View File
@@ -4,6 +4,7 @@ loadEnvConfig(process.cwd(), process.env.NODE_ENV !== 'production')
import { workflowService } from '@shumai/workflow-core'
import { TaskQueueAgent } from '@shumai/workflow-core'
import { initAgentWorkflows } from '@shumai/agent'
import { sandboxService } from '@shumai/core'
import { handleDaemonCommands } from '@shumai/core/src/utils/daemon'
if (process.argv.includes('--check')) {
@@ -14,6 +15,9 @@ if (process.argv.includes('--check')) {
async function run() {
// Initialize workflows and activities
initAgentWorkflows()
await sandboxService.ensureInitialized().catch((err) => {
console.error('Failed to eagerly initialize sandbox in agent worker:', err)
})
console.log('🚀 Starting Agent Worker...')
-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'
+34
View File
@@ -20,6 +20,9 @@ export SHUMAI_API_SERVER="http://localhost:3000"
# Your personal API Token (Generate this in the WebUI via Settings -> Developer tab)
export SHUMAI_API_KEY="your-developer-api-token"
# Optional: Enable asset deletion capability (disabled by default for safety)
export SHUMAI_ALLOW_DELETE="true"
```
---
@@ -89,6 +92,37 @@ shumai-cli create-version <localFilePath> -p <parentAssetId>
- **Options:**
- `-p`, `--parent <id>`: The parent asset ID (file or version stack) to version (required).
#### 6. Rename an Asset
Rename an existing file or folder in Shumai.
```bash
shumai-cli rename <assetId> <newName>
```
#### 7. Move Assets
Move one or more assets (files or folders) to a destination parent folder. Note that all assets to be moved must belong to the same current parent folder.
```bash
shumai-cli move <assetId...> -p <parentId>
# or using the short alias:
shumai-cli mv <assetId...> -p <parentId>
```
- **Options:**
- `-p`, `--parent <id>`: The destination parent folder ID (required).
#### 8. Delete an Asset
Delete a single file or folder by moving it to the Trash bin. For safety, this command only deletes one asset at a time and requires the `SHUMAI_ALLOW_DELETE="true"` environment variable to be set in your environment.
```bash
shumai-cli delete <assetId>
# or using the short alias:
shumai-cli rm <assetId>
```
---
## Development
+3 -3
View File
@@ -1,6 +1,6 @@
{
"name": "@shumai/cli",
"version": "0.3.8",
"version": "0.4.6",
"private": true,
"type": "module",
"bin": {
@@ -11,7 +11,7 @@
"@shumai/core": "workspace:*",
"@shumai/dtos": "workspace:*",
"@shumai/tableprinter": "workspace:*",
"hono": "4.12.23",
"ulid": "^3.0.2"
"hono": "4.13.5",
"ulid": "3.0.2"
}
}
+210
View File
@@ -5,6 +5,9 @@ import { mkdir } from './mkdir'
import { getClient } from '../client'
import { upload } from './upload'
import { createVersion } from './create-version'
import { rename } from './rename'
import { move } from './move'
import { deleteAsset } from './delete'
import fs from 'node:fs'
import http from 'node:http'
@@ -34,17 +37,29 @@ describe('CLI Commands', () => {
$get: vi.fn(),
':projectId': {
$get: vi.fn(),
reparent: {
$post: vi.fn(),
},
},
},
folders: {
$post: vi.fn(),
$delete: vi.fn(),
':folderId': {
$get: vi.fn(),
$put: vi.fn(),
children: {
$get: vi.fn(),
},
},
},
files: {
$delete: vi.fn(),
':fileId': {
$get: vi.fn(),
$put: vi.fn(),
},
},
teams: {
':teamId': {
upload: {
@@ -60,6 +75,8 @@ describe('CLI Commands', () => {
},
}
const originalAllowDelete = process.env.SHUMAI_ALLOW_DELETE
beforeEach(() => {
vi.resetAllMocks()
logSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
@@ -79,6 +96,11 @@ describe('CLI Commands', () => {
writeSpy.mockRestore()
errorSpy.mockRestore()
exitSpy.mockRestore()
if (originalAllowDelete !== undefined) {
process.env.SHUMAI_ALLOW_DELETE = originalAllowDelete
} else {
delete process.env.SHUMAI_ALLOW_DELETE
}
})
describe('project ls', () => {
@@ -361,4 +383,192 @@ describe('CLI Commands', () => {
}
})
})
describe('rename', () => {
it('exits with error when assetId or newName is missing', async () => {
await expect(rename('', 'new-name')).rejects.toThrow('process.exit(1)')
expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('Asset ID is required'))
await expect(rename('asset-1', '')).rejects.toThrow('process.exit(1)')
expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('New name is required'))
})
it('renames a folder when asset type is folder', async () => {
mockClient.api.folders[':folderId'].$get.mockResolvedValue({
ok: true,
json: async () => ({ id: 'f-1', type: 'folder' }),
} as unknown as Response)
mockClient.api.folders[':folderId'].$put.mockResolvedValue({
ok: true,
json: async () => ({ id: 'f-1', name: 'Renamed Folder' }),
} as unknown as Response)
await rename('f-1', 'Renamed Folder')
expect(mockClient.api.folders[':folderId'].$put).toHaveBeenCalledWith({
param: { folderId: 'f-1' },
json: { name: 'Renamed Folder' },
})
expect(logSpy).toHaveBeenCalledWith('Renamed asset f-1 to "Renamed Folder"')
})
it('renames a file when asset type is file', async () => {
mockClient.api.folders[':folderId'].$get.mockResolvedValue({
ok: true,
json: async () => ({ id: 'file-1', type: 'file' }),
} as unknown as Response)
mockClient.api.files[':fileId'].$put.mockResolvedValue({
ok: true,
json: async () => ({ id: 'file-1', name: 'new.mp4' }),
} as unknown as Response)
await rename('file-1', 'new.mp4')
expect(mockClient.api.files[':fileId'].$put).toHaveBeenCalledWith({
param: { fileId: 'file-1' },
json: { name: 'new.mp4' },
})
expect(logSpy).toHaveBeenCalledWith('Renamed asset file-1 to "new.mp4"')
})
it('exits with error when asset fetch fails', async () => {
mockClient.api.folders[':folderId'].$get.mockResolvedValue({
ok: false,
json: async () => ({ error: 'Asset not found' }),
} as unknown as Response)
await expect(rename('unknown-id', 'name')).rejects.toThrow('process.exit(1)')
expect(errorSpy).toHaveBeenCalledWith('Error: Asset not found')
})
})
describe('move', () => {
it('exits with error when assetIds or parentId is missing', async () => {
await expect(move([], 'parent-1')).rejects.toThrow('process.exit(1)')
expect(errorSpy).toHaveBeenCalledWith(
expect.stringContaining('At least one asset ID is required'),
)
await expect(move(['a-1'], '')).rejects.toThrow('process.exit(1)')
expect(errorSpy).toHaveBeenCalledWith(
expect.stringContaining('Option -p/--parent <parentId> is required'),
)
})
it('successfully moves assets', async () => {
mockClient.api.folders[':folderId'].$get.mockResolvedValue({
ok: true,
json: async () => ({ id: 'parent-1', projectId: 'proj-1' }),
} as unknown as Response)
mockClient.api.projects[':projectId'].reparent.$post.mockResolvedValue({
ok: true,
} as unknown as Response)
await move(['a-1', 'a-2'], 'parent-1')
expect(mockClient.api.projects[':projectId'].reparent.$post).toHaveBeenCalledWith({
param: { projectId: 'proj-1' },
json: {
assetIds: ['a-1', 'a-2'],
newParentId: 'parent-1',
},
})
expect(logSpy).toHaveBeenCalledWith('Moved 2 asset(s) to parent parent-1')
})
it('exits with error when destination parent is not found', async () => {
mockClient.api.folders[':folderId'].$get.mockResolvedValue({
ok: false,
json: async () => ({ error: 'Folder not found' }),
} as unknown as Response)
await expect(move(['a-1'], 'missing-parent')).rejects.toThrow('process.exit(1)')
expect(errorSpy).toHaveBeenCalledWith('Error: Folder not found')
})
})
describe('deleteAsset', () => {
it('exits with error when SHUMAI_ALLOW_DELETE is not set or not true', async () => {
delete process.env.SHUMAI_ALLOW_DELETE
await expect(deleteAsset(['a-1'])).rejects.toThrow('process.exit(1)')
expect(errorSpy).toHaveBeenCalledWith(
'Error: Asset deletion is disabled in this environment.',
)
})
it('exits with error when assetIds is empty', async () => {
process.env.SHUMAI_ALLOW_DELETE = 'true'
await expect(deleteAsset([])).rejects.toThrow('process.exit(1)')
expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('Asset ID is required'))
})
it('exits with error when more than one asset ID is passed', async () => {
process.env.SHUMAI_ALLOW_DELETE = 'true'
await expect(deleteAsset(['a-1', 'a-2'])).rejects.toThrow('process.exit(1)')
expect(errorSpy).toHaveBeenCalledWith('Error: Can only delete one asset at a time.')
})
it('exits with error when asset is not found', async () => {
process.env.SHUMAI_ALLOW_DELETE = 'true'
mockClient.api.folders[':folderId'].$get.mockResolvedValue({
ok: false,
json: async () => ({ error: 'Asset not found' }),
} as unknown as Response)
await expect(deleteAsset(['a-1'])).rejects.toThrow('process.exit(1)')
expect(errorSpy).toHaveBeenCalledWith('Error: Asset not found')
})
it('successfully deletes a file when SHUMAI_ALLOW_DELETE is true', async () => {
process.env.SHUMAI_ALLOW_DELETE = 'true'
mockClient.api.folders[':folderId'].$get.mockResolvedValue({
ok: true,
json: async () => ({ id: 'a-1', type: 'file' }),
} as unknown as Response)
mockClient.api.files.$delete.mockResolvedValue({
ok: true,
} as unknown as Response)
await deleteAsset(['a-1'])
expect(mockClient.api.files.$delete).toHaveBeenCalledWith({
json: { ids: ['a-1'] },
})
expect(mockClient.api.folders.$delete).not.toHaveBeenCalled()
expect(logSpy).toHaveBeenCalledWith('Deleted asset a-1')
})
it('successfully deletes a folder when SHUMAI_ALLOW_DELETE is 1', async () => {
process.env.SHUMAI_ALLOW_DELETE = '1'
mockClient.api.folders[':folderId'].$get.mockResolvedValue({
ok: true,
json: async () => ({ id: 'folder-1', type: 'folder' }),
} as unknown as Response)
mockClient.api.folders.$delete.mockResolvedValue({
ok: true,
} as unknown as Response)
await deleteAsset(['folder-1'])
expect(mockClient.api.folders.$delete).toHaveBeenCalledWith({
json: { ids: ['folder-1'] },
})
expect(logSpy).toHaveBeenCalledWith('Deleted asset folder-1')
})
it('exits with error when delete API returns an error', async () => {
process.env.SHUMAI_ALLOW_DELETE = 'true'
mockClient.api.folders[':folderId'].$get.mockResolvedValue({
ok: true,
json: async () => ({ id: 'a-1', type: 'file' }),
} as unknown as Response)
mockClient.api.files.$delete.mockResolvedValue({
ok: false,
json: async () => ({ error: 'Failed to delete' }),
} as unknown as Response)
await expect(deleteAsset(['a-1'])).rejects.toThrow('process.exit(1)')
expect(errorSpy).toHaveBeenCalledWith('Error: Failed to delete')
})
})
})
+62
View File
@@ -0,0 +1,62 @@
import { getClient } from '../client'
export async function deleteAsset(assetIds: string[]) {
const isAllowed =
process.env.SHUMAI_ALLOW_DELETE === 'true' || process.env.SHUMAI_ALLOW_DELETE === '1'
if (!isAllowed) {
console.error('Error: Asset deletion is disabled in this environment.')
process.exit(1)
}
if (!assetIds || assetIds.length === 0) {
console.error('Error: Asset ID is required. Usage: shumai-cli delete <assetId>')
process.exit(1)
}
if (assetIds.length > 1) {
console.error('Error: Can only delete one asset at a time.')
process.exit(1)
}
const assetId = assetIds[0]
const client = getClient()
try {
// Inspect asset to determine whether it is a folder or file
const getRes = await client.api.folders[':folderId'].$get({
param: { folderId: assetId },
})
if (!getRes.ok) {
const err = (await getRes.json().catch(() => ({ error: 'Asset not found' }))) as {
error?: string
}
console.error(`Error: ${err.error || 'Asset not found'}`)
process.exit(1)
}
const asset = await getRes.json()
const isFolder = asset.type === 'folder'
const res = isFolder
? await client.api.folders.$delete({
json: { ids: [assetId] },
})
: await client.api.files.$delete({
json: { ids: [assetId] },
})
if (!res.ok) {
const err = (await res.json().catch(() => ({ error: 'Failed to delete asset' }))) as {
error?: string
}
console.error(`Error: ${err.error || 'Failed to delete asset'}`)
process.exit(1)
}
console.log(`Deleted asset ${assetId}`)
} catch (err) {
console.error('Error connecting to API server:', err instanceof Error ? err.message : err)
process.exit(1)
}
}
+59
View File
@@ -0,0 +1,59 @@
import { getClient } from '../client'
export async function move(assetIds: string[], parentId: string) {
if (!assetIds || assetIds.length === 0) {
console.error(
'Error: At least one asset ID is required. Usage: shumai-cli move <assetId...> -p <parentId>',
)
process.exit(1)
}
if (!parentId) {
console.error('Error: Option -p/--parent <parentId> is required.')
process.exit(1)
}
const client = getClient()
try {
// Fetch destination folder to get its projectId
const parentRes = await client.api.folders[':folderId'].$get({
param: { folderId: parentId },
})
if (!parentRes.ok) {
const err = (await parentRes.json().catch(() => ({ error: 'Parent folder not found' }))) as {
error?: string
}
console.error(`Error: ${err.error || 'Parent folder not found'}`)
process.exit(1)
}
const parentInfo = await parentRes.json()
const projectId = parentInfo.projectId
if (!projectId) {
console.error('Error: Destination parent folder is not associated with a project.')
process.exit(1)
}
const res = await client.api.projects[':projectId'].reparent.$post({
param: { projectId },
json: {
assetIds,
newParentId: parentId,
},
})
if (!res.ok) {
const err = (await res.json().catch(() => ({ error: 'Failed to move assets' }))) as {
error?: string
}
console.error(`Error: ${err.error || 'Failed to move assets'}`)
process.exit(1)
}
console.log(`Moved ${assetIds.length} asset(s) to parent ${parentId}`)
} catch (err) {
console.error('Error connecting to API server:', err instanceof Error ? err.message : err)
process.exit(1)
}
}
+55
View File
@@ -0,0 +1,55 @@
import { getClient } from '../client'
export async function rename(assetId: string, newName: string) {
if (!assetId) {
console.error('Error: Asset ID is required. Usage: shumai-cli rename <assetId> <newName>')
process.exit(1)
}
if (!newName) {
console.error('Error: New name is required. Usage: shumai-cli rename <assetId> <newName>')
process.exit(1)
}
const client = getClient()
try {
// Determine whether asset is a folder or a file
const getRes = await client.api.folders[':folderId'].$get({
param: { folderId: assetId },
})
if (!getRes.ok) {
const err = (await getRes.json().catch(() => ({ error: 'Asset not found' }))) as {
error?: string
}
console.error(`Error: ${err.error || 'Asset not found'}`)
process.exit(1)
}
const asset = await getRes.json()
const isFolder = asset.type === 'folder'
const updateRes = isFolder
? await client.api.folders[':folderId'].$put({
param: { folderId: assetId },
json: { name: newName },
})
: await client.api.files[':fileId'].$put({
param: { fileId: assetId },
json: { name: newName },
})
if (!updateRes.ok) {
const err = (await updateRes.json().catch(() => ({ error: 'Failed to rename asset' }))) as {
error?: string
}
console.error(`Error: ${err.error || 'Failed to rename asset'}`)
process.exit(1)
}
console.log(`Renamed asset ${assetId} to "${newName}"`)
} catch (err) {
console.error('Error connecting to API server:', err instanceof Error ? err.message : err)
process.exit(1)
}
}
+37 -1
View File
@@ -3,6 +3,9 @@ import { ls } from './commands/ls'
import { mkdir } from './commands/mkdir'
import { upload } from './commands/upload'
import { createVersion } from './commands/create-version'
import { rename } from './commands/rename'
import { move } from './commands/move'
import { deleteAsset } from './commands/delete'
function printHelp() {
console.log(`
@@ -14,9 +17,12 @@ Commands:
mkdir <name> -p <parentId> Create a new folder in a parent folder
upload <path> -p <parentId> Upload a local file or folder to a parent folder
create-version <path> -p <id> Create a new version of an existing file or version stack
rename <assetId> <newName> Rename an existing file or folder
move <assetIds...> -p <target> Move one or more assets to a destination parent folder (alias: mv)
delete <assetId> Delete a single file or folder (alias: rm)
Options:
-p, --parent <id> The parent folder/asset ID (required for ls, mkdir, upload, create-version)
-p, --parent <id> The parent folder/asset ID (required for ls, mkdir, upload, create-version, move)
-h, --help Show help details
`)
}
@@ -92,6 +98,36 @@ async function main() {
process.exit(1)
}
await createVersion(localPath, parentId)
} else if (cmd === 'rename') {
const assetId = cleanArgs[1]
const newName = cleanArgs[2]
if (!assetId || !newName) {
console.error(
'Error: Asset ID and new name are required. Usage: shumai-cli rename <assetId> <newName>',
)
process.exit(1)
}
await rename(assetId, newName)
} else if (cmd === 'move' || cmd === 'mv') {
const assetIds = cleanArgs.slice(1)
if (assetIds.length === 0) {
console.error(
'Error: At least one asset ID is required. Usage: shumai-cli move <assetId...> -p <parentId>',
)
process.exit(1)
}
if (!parentId) {
console.error('Error: Option -p/--parent <parentId> is required.')
process.exit(1)
}
await move(assetIds, parentId)
} else if (cmd === 'delete' || cmd === 'rm') {
const assetIds = cleanArgs.slice(1)
if (assetIds.length === 0) {
console.error('Error: Asset ID is required. Usage: shumai-cli delete <assetId>')
process.exit(1)
}
await deleteAsset(assetIds)
} else {
console.error(`Error: Unknown command "${cmd}". Run "shumai-cli --help" for usage.`)
process.exit(1)
+41
View File
@@ -0,0 +1,41 @@
# Premiere UXP Plugin Guidelines
## Component Library (Spectrum Web Components / SWC)
- **Always prefer SWC components if possible**: Use Spectrum Web Component React wrappers (`@swc-react/*`) and `@swc-uxp-wrappers/*` for UI elements (Button, ActionButton, Textfield, Card, Divider, ProgressCircle, StatusLight, Badge, Search, FieldLabel, HelpText, IllustratedMessage, ActionGroup, etc.) rather than hand-crafting custom HTML/CSS elements.
- **SWC Support**: `public/manifest.json` has `"featureFlags": { "enableSWCSupport": true }`.
- **Package Versions**: Keep SWC packages aligned at version `0.37.0` (matching Adobe UXP compatibility).
- **Bundler Aliases**: `build.ts` uses `swcAliasPlugin` with `aliases` from `@swc-uxp-wrappers/utils` to resolve internal SWC imports for Bun.
## Icons
- **Always use Spectrum Workflow Icons (`@spectrum-web-components/icons-workflow`)**: Never use external icon libraries like `lucide-react`.
- **Registration**: All workflow icons used must be imported and registered in `src/index.tsx` (e.g. `import '@spectrum-web-components/icons-workflow/icons/sp-icon-movie-camera.js'`). Note: Ensure the icon exists in `@spectrum-web-components/icons-workflow/icons/` (Spectrum 1 compatible) rather than only `icons-s2/` (which falls back to an empty circular DefaultIcon under Spectrum 1).
- **Typing**: Add custom element declarations to `src/declarations.d.ts` under both `declare namespace React.JSX` and `declare global.JSX.IntrinsicElements` with `SpIconCustomElementProps`.
## Adobe UXP Layout Engine Rules (Critical CSS Gotchas)
Adobe UXP's layout engine (Yoga-based) does **not** support several standard modern CSS features:
1. **No CSS Grid**:
- `display: grid` and `grid-template-columns` are **unsupported / invalid**.
- Always use Flexbox (`display: flex; flex-direction: row | column;`).
2. **No `aspect-ratio`**:
- `aspect-ratio` is invalid in UXP and collapses containers to `0px` height.
- Always specify explicit `width` and `height` on preview / thumbnail containers.
3. **No `box-sizing: border-box`**:
- `box-sizing` is not supported (UXP elements are natively border-box). Specifying it logs invalid property warnings.
4. **No `gap` in Flexbox**:
- `gap` is invalid in Premiere UXP flexbox. Items will render with 0px spacing.
- Use `margin-bottom` or `margin-right` on child items for spacing.
5. **Always Set `flex-shrink: 0` on List Items**:
- Flex children default to `flex-shrink: 1`. When rendering lists with many items (>10 items), flexbox squishes the items down to slivers instead of scrolling.
- Always add `flex-shrink: 0` and an explicit `min-height` to list row cards (`.project-row-card`, `.file-row-card`, `.item-row`, etc.).
6. **Scroll Containers**:
- Scrollable flex children (like `.view-content`) must have `min-height: 0` and `overflow-y: auto` to allow children to overflow and scroll vertically.
## Build and Packaging Commands
- **Build**: `bun run --filter @shumai/premiere-uxp build`
- **Watch mode**: `bun run --filter @shumai/premiere-uxp dev`
- **Package CCX**: `bun run --filter @shumai/premiere-uxp package` (outputs `apps/premiere-uxp/shumai-premiere.ccx`)
+109
View File
@@ -0,0 +1,109 @@
#!/usr/bin/env bun
import { cp, rm, mkdir } from 'node:fs/promises'
import { existsSync, watch } from 'node:fs'
import { $ } from 'bun'
import { aliases } from '@swc-uxp-wrappers/utils'
import type { BunPlugin } from 'bun'
const swcAliasPlugin: BunPlugin = {
name: 'swc-uxp-aliases',
setup(build) {
for (const [key, target] of Object.entries(aliases)) {
const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
const filter = new RegExp(`^${escaped}(/.*)?$`)
build.onResolve({ filter }, (args) => {
const subpath = args.path.slice(key.length)
const targetPath = target + subpath
try {
return { path: import.meta.resolveSync(targetPath) }
} catch {
return undefined
}
})
}
},
}
const isWatch = process.argv.includes('--watch')
const isPackage = process.argv.includes('--package')
async function build(): Promise<boolean> {
const start = performance.now()
try {
if (!existsSync('dist')) {
await mkdir('dist', { recursive: true })
}
// 1. Copy public assets (manifest, index.html, styles, icons)
await cp('public', 'dist', { recursive: true })
// 2. Bundle with Bun.build
const result = await Bun.build({
entrypoints: ['./src/index.tsx'],
outdir: './dist',
naming: 'index.js',
target: 'browser',
format: 'cjs',
sourcemap: 'external',
minify: false,
plugins: [swcAliasPlugin],
external: ['os', 'premierepro', 'uxp'],
define: {
'process.env.NODE_ENV': JSON.stringify('production'),
},
})
if (!result.success) {
console.error('❌ Build failed:')
for (const log of result.logs) {
console.error(log)
}
return false
}
const elapsed = (performance.now() - start).toFixed(1)
console.log(`✅ Build completed in ${elapsed}ms`)
// 3. Package .ccx if requested
if (isPackage) {
console.log('📦 Packaging shumai-premiere.ccx...')
if (existsSync('shumai-premiere.ccx')) {
await rm('shumai-premiere.ccx')
}
await $`cd dist && zip -r ../shumai-premiere.ccx . -x '*.map' -x '.DS_Store' -x '__MACOSX*'`
console.log('✅ Package created.')
}
return true
} catch (err) {
console.error('❌ Build error:', err)
return false
}
}
// Clean and run initial build
if (existsSync('dist')) {
await rm('dist', { recursive: true, force: true })
}
const success = await build()
if (!success && !isWatch) {
process.exit(1)
}
// Watch mode
if (isWatch) {
console.log('👀 Watching src/ and public/ for changes...')
let building = false
const triggerRebuild = async (dir: string) => {
if (building) return
building = true
setTimeout(async () => {
console.log(`\n🔄 Change detected in ${dir}, rebuilding...`)
await build()
building = false
}, 50)
}
watch('./src', { recursive: true }, () => triggerRebuild('src'))
watch('./public', { recursive: true }, () => triggerRebuild('public'))
}
+62
View File
@@ -0,0 +1,62 @@
{
"name": "@shumai/premiere-uxp",
"version": "0.4.6",
"private": true,
"type": "commonjs",
"scripts": {
"build": "bun run ./build.ts",
"dev": "bun run ./build.ts --watch",
"package": "bun run ./build.ts --package",
"clean": "rm -rf dist"
},
"dependencies": {
"@shumai/api": "workspace:*",
"@shumai/dtos": "workspace:*",
"@spectrum-web-components/action-menu": "0.37.0",
"@spectrum-web-components/badge": "0.37.0",
"@spectrum-web-components/icon": "1.12.2",
"@spectrum-web-components/icons-workflow": "1.12.2",
"@spectrum-web-components/menu": "0.37.0",
"@spectrum-web-components/progress-circle": "0.37.0",
"@spectrum-web-components/status-light": "0.37.0",
"@spectrum-web-components/theme": "0.37.0",
"@swc-react/action-button": "0.37.0",
"@swc-react/action-group": "0.37.0",
"@swc-react/action-menu": "0.37.0",
"@swc-react/badge": "0.37.0",
"@swc-react/button": "0.37.0",
"@swc-react/card": "0.37.0",
"@swc-react/divider": "0.37.0",
"@swc-react/field-label": "0.37.0",
"@swc-react/help-text": "0.37.0",
"@swc-react/illustrated-message": "0.37.0",
"@swc-react/menu": "0.37.0",
"@swc-react/progress-circle": "0.37.0",
"@swc-react/search": "0.37.0",
"@swc-react/status-light": "0.37.0",
"@swc-react/textfield": "0.37.0",
"@swc-react/theme": "0.37.0",
"@swc-uxp-wrappers/action-button": "2.0.0",
"@swc-uxp-wrappers/action-group": "2.0.0",
"@swc-uxp-wrappers/button": "2.0.0",
"@swc-uxp-wrappers/card": "2.0.0",
"@swc-uxp-wrappers/divider": "2.0.0",
"@swc-uxp-wrappers/field-label": "2.0.0",
"@swc-uxp-wrappers/help-text": "2.0.0",
"@swc-uxp-wrappers/illustrated-message": "2.0.0",
"@swc-uxp-wrappers/menu": "2.0.0",
"@swc-uxp-wrappers/overlay": "2.0.0",
"@swc-uxp-wrappers/popover": "2.0.0",
"@swc-uxp-wrappers/search": "2.0.0",
"@swc-uxp-wrappers/textfield": "2.0.0",
"@swc-uxp-wrappers/utils": "2.0.1",
"hono": "4.13.5",
"react": "19.2.8",
"react-dom": "19.2.8"
},
"devDependencies": {
"@adobe/premierepro": "26.3.0",
"@types/react": "19.2.18",
"@types/react-dom": "19.2.7"
}
}
Binary file not shown.

After

Width:  |  Height:  |  Size: 4.1 KiB

+13
View File
@@ -0,0 +1,13 @@
<!doctype html>
<html lang="en">
<head>
<meta charset="UTF-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>Shumai</title>
<link rel="stylesheet" href="./styles.css" />
<script defer src="./index.js"></script>
</head>
<body>
<div id="root"></div>
</body>
</html>
+61
View File
@@ -0,0 +1,61 @@
{
"id": "com.shumai.premiere",
"name": "Shumai",
"shortname": "shumai",
"version": "0.1.0",
"main": "index.html",
"host": {
"app": "premierepro",
"minVersion": "25.1.0"
},
"manifestVersion": 5,
"featureFlags": {
"enableSWCSupport": true
},
"requiredPermissions": {
"network": {
"domains": "all"
},
"localFileSystem": "request",
"clipboard": "readAndWrite"
},
"entrypoints": [
{
"id": "shumaiPanel",
"type": "panel",
"minimumSize": {
"width": 320,
"height": 480
},
"maximumSize": {
"width": 2000,
"height": 2000
},
"preferredDockedSize": {
"width": 400,
"height": 720
},
"preferredFloatingSize": {
"width": 460,
"height": 780
},
"label": {
"default": "Shumai"
},
"icons": [
{
"width": 114,
"height": 114,
"path": "icons/icon.png"
}
]
}
],
"icons": [
{
"width": 114,
"height": 114,
"path": "icons/icon.png"
}
]
}
File diff suppressed because it is too large Load Diff
Binary file not shown.
+123
View File
@@ -0,0 +1,123 @@
import React, { useEffect, useState } from 'react'
import { Header } from './components/Header'
import { NavigationTabs, type MainTab } from './components/NavigationTabs'
import { AuthView } from './views/AuthView'
import { ProjectsView, ProjectSummary } from './views/ProjectsView'
import { FileListView } from './views/FileListView'
import { SequencesView } from './views/SequencesView'
import { getStoredCredentials, clearStoredCredentials } from './services/storage'
import { getAllSequenceLinksFromCache } from './services/linkStorage'
import { resetClient } from './api/client'
import { autoSyncService } from './services/autoSyncService'
import { ProgressCircle } from '@swc-react/progress-circle'
type AppView = 'auth' | 'projects' | 'files'
export const App: React.FC = () => {
const [view, setView] = useState<AppView>('auth')
const [mainTab, setMainTab] = useState<MainTab>('browse')
const [linkedCount, setLinkedCount] = useState<number>(0)
const [endpoint, setEndpoint] = useState<string>('')
const [apiKey, setApiKey] = useState<string>('')
const [selectedProject, setSelectedProject] = useState<ProjectSummary | null>(null)
const [initialLoading, setInitialLoading] = useState(true)
useEffect(() => {
const creds = getStoredCredentials()
if (creds && creds.endpoint && creds.apiKey) {
setEndpoint(creds.endpoint)
setApiKey(creds.apiKey)
setView('projects')
autoSyncService.start(creds.endpoint, creds.apiKey)
const cached = getAllSequenceLinksFromCache()
setLinkedCount(cached.length)
} else {
setView('auth')
}
setInitialLoading(false)
return () => {
autoSyncService.stop()
}
}, [])
const handleConnectSuccess = (newEndpoint: string, newApiKey: string) => {
setEndpoint(newEndpoint)
setApiKey(newApiKey)
setView('projects')
autoSyncService.start(newEndpoint, newApiKey)
}
const handleDisconnect = () => {
autoSyncService.stop()
clearStoredCredentials()
resetClient()
setEndpoint('')
setApiKey('')
setSelectedProject(null)
setView('auth')
setMainTab('browse')
}
const handleSelectProject = (project: ProjectSummary) => {
setSelectedProject(project)
setView('files')
setMainTab('browse')
}
const handleBackToProjects = () => {
setSelectedProject(null)
setView('projects')
setMainTab('browse')
}
if (initialLoading) {
return (
<div className="app-container">
<Header />
<div className="view-content" style={{ justifyContent: 'center', alignItems: 'center' }}>
<ProgressCircle indeterminate size="l" label="Loading Shumai..." />
</div>
</div>
)
}
return (
<div className="app-container">
<Header
endpoint={view !== 'auth' ? endpoint : undefined}
onDisconnect={view !== 'auth' ? handleDisconnect : undefined}
/>
{view !== 'auth' && (
<NavigationTabs activeTab={mainTab} onTabChange={setMainTab} linkedCount={linkedCount} />
)}
{view === 'auth' && (
<AuthView
initialEndpoint={endpoint || 'http://localhost:3000'}
initialApiKey={apiKey}
onConnectSuccess={handleConnectSuccess}
/>
)}
{view !== 'auth' && mainTab === 'sequences' && (
<SequencesView endpoint={endpoint} apiKey={apiKey} onLinkCountChange={setLinkedCount} />
)}
{view !== 'auth' && mainTab === 'browse' && view === 'projects' && (
<ProjectsView endpoint={endpoint} apiKey={apiKey} onSelectProject={handleSelectProject} />
)}
{view !== 'auth' && mainTab === 'browse' && view === 'files' && selectedProject && (
<FileListView
endpoint={endpoint}
apiKey={apiKey}
project={selectedProject}
onBackToProjects={handleBackToProjects}
onLinkCountChange={setLinkedCount}
/>
)}
</div>
)
}
+31
View File
@@ -0,0 +1,31 @@
import { hc } from 'hono/client'
import type { AppType } from '@shumai/api'
export type ShumaiClient = ReturnType<typeof hc<AppType>>
let currentClient: ShumaiClient | null = null
let currentKey = ''
export function getShumaiClient(endpoint: string, apiKey: string): ShumaiClient {
const normalizedEndpoint = endpoint.trim().replace(/\/+$/, '')
const cacheKey = `${normalizedEndpoint}::${apiKey}`
if (currentClient && currentKey === cacheKey) {
return currentClient
}
currentClient = hc<AppType>(normalizedEndpoint, {
headers: {
Authorization: `Bearer ${apiKey}`,
'x-api-key': apiKey,
},
})
currentKey = cacheKey
return currentClient
}
export function resetClient(): void {
currentClient = null
currentKey = ''
}
@@ -0,0 +1,61 @@
import React from 'react'
import { Divider } from '@swc-react/divider'
export interface BreadcrumbCrumb {
id: string
name: string
}
interface BreadcrumbProps {
projectName?: string
crumbs: BreadcrumbCrumb[]
onNavigateToProjects: () => void
onNavigateToCrumb: (index: number) => void
}
export const Breadcrumb: React.FC<BreadcrumbProps> = ({
projectName,
crumbs,
onNavigateToProjects,
onNavigateToCrumb,
}) => {
return (
<>
<nav className="breadcrumb-bar" aria-label="Folder Path">
<span className="breadcrumb-item" onClick={onNavigateToProjects} title="Back to Projects">
Projects
</span>
{projectName && (
<>
<span className="breadcrumb-separator">/</span>
<span
className={`breadcrumb-item ${crumbs.length === 0 ? 'active' : ''}`}
onClick={() => onNavigateToCrumb(-1)}
title={projectName}
>
{projectName}
</span>
</>
)}
{crumbs.map((crumb, idx) => {
const isLast = idx === crumbs.length - 1
return (
<React.Fragment key={crumb.id}>
<span className="breadcrumb-separator">/</span>
<span
className={`breadcrumb-item ${isLast ? 'active' : ''}`}
onClick={() => (!isLast ? onNavigateToCrumb(idx) : undefined)}
title={crumb.name}
>
{crumb.name}
</span>
</React.Fragment>
)
})}
</nav>
<Divider size="s" />
</>
)
}
@@ -0,0 +1,409 @@
// @vitest-environment happy-dom
import React from 'react'
import { describe, it, expect, vi, afterEach } from 'vitest'
import { render, screen, fireEvent, cleanup } from '@testing-library/react'
import {
getFileTypeCategory,
getAssetVersionLabel,
FileItem,
FileCardItem,
type AssetSummary,
} from './FileItem'
// Configure React 19 act environment for happy-dom
;(globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true
describe('getFileTypeCategory', () => {
it('identifies folder type', () => {
const asset: AssetSummary = {
id: 'f1',
name: 'My Folder',
type: 'folder',
}
expect(getFileTypeCategory(asset)).toBe('folder')
})
it('identifies video by mimeType', () => {
const asset: AssetSummary = {
id: 'v1',
name: 'clip.dat',
type: 'file',
mimeType: 'video/mp4',
}
expect(getFileTypeCategory(asset)).toBe('video')
})
it('identifies video by extension', () => {
const extensions = ['mp4', 'mov', 'avi', 'mkv', 'm4v', 'webm']
for (const ext of extensions) {
const asset: AssetSummary = {
id: `v-${ext}`,
name: `sample.${ext}`,
type: 'file',
}
expect(getFileTypeCategory(asset)).toBe('video')
}
})
it('identifies audio by mimeType or extension', () => {
const asset1: AssetSummary = {
id: 'a1',
name: 'audio.raw',
type: 'file',
mimeType: 'audio/wav',
}
const asset2: AssetSummary = {
id: 'a2',
name: 'track.mp3',
type: 'file',
}
expect(getFileTypeCategory(asset1)).toBe('audio')
expect(getFileTypeCategory(asset2)).toBe('audio')
})
it('identifies image by mimeType or extension', () => {
const asset1: AssetSummary = {
id: 'i1',
name: 'photo.bin',
type: 'file',
mimeType: 'image/png',
}
const asset2: AssetSummary = {
id: 'i2',
name: 'art.jpg',
type: 'file',
}
expect(getFileTypeCategory(asset1)).toBe('image')
expect(getFileTypeCategory(asset2)).toBe('image')
})
it('falls back to generic file', () => {
const asset: AssetSummary = {
id: 'doc1',
name: 'notes.pdf',
type: 'file',
mimeType: 'application/pdf',
}
expect(getFileTypeCategory(asset)).toBe('file')
})
})
describe('FileItem and FileCardItem UI Components', () => {
afterEach(() => {
cleanup()
vi.clearAllMocks()
})
const mockOnClick = vi.fn()
const mockOnImportRaw = vi.fn()
const mockOnSelectVideoForImport = vi.fn()
const folderAsset: AssetSummary = {
id: 'folder-1',
name: 'Raw Footage',
type: 'folder',
fileCount: 5,
}
const imageAsset: AssetSummary = {
id: 'img-1',
name: 'logo.png',
type: 'file',
mimeType: 'image/png',
sizeByte: 2048,
}
const videoAsset: AssetSummary = {
id: 'vid-1',
name: 'interview.mp4',
type: 'file',
mimeType: 'video/mp4',
sizeByte: 50 * 1024 * 1024,
}
it('FileItem navigates into folder on click without download button', () => {
render(
<FileItem
asset={folderAsset}
onClick={mockOnClick}
onImportRaw={mockOnImportRaw}
onSelectVideoForImport={mockOnSelectVideoForImport}
/>,
)
expect(screen.getByText('Raw Footage')).toBeTruthy()
expect(screen.queryByTitle('Import into Premiere Pro')).toBeNull()
fireEvent.click(screen.getByText('Raw Footage'))
expect(mockOnClick).toHaveBeenCalled()
expect(mockOnImportRaw).not.toHaveBeenCalled()
})
it('FileCardItem calls onImportRaw when download button is clicked for non-video, but clicking card does not', () => {
render(
<FileCardItem
asset={imageAsset}
onClick={mockOnClick}
onImportRaw={mockOnImportRaw}
onSelectVideoForImport={mockOnSelectVideoForImport}
/>,
)
expect(screen.getByText('logo.png')).toBeTruthy()
// Clicking the file title / card text should NOT trigger import
fireEvent.click(screen.getByText('logo.png'))
expect(mockOnImportRaw).not.toHaveBeenCalled()
const downloadBtn = screen.getByTitle('Import into Premiere Pro')
expect(downloadBtn).toBeTruthy()
fireEvent.click(downloadBtn)
expect(mockOnImportRaw).toHaveBeenCalledWith(imageAsset)
})
it('FileCardItem calls onSelectVideoForImport when download button is clicked for video', () => {
render(
<FileCardItem
asset={videoAsset}
onClick={mockOnClick}
onImportRaw={mockOnImportRaw}
onSelectVideoForImport={mockOnSelectVideoForImport}
/>,
)
expect(screen.getByText('interview.mp4')).toBeTruthy()
const downloadBtn = screen.getByTitle('Import into Premiere Pro')
fireEvent.click(downloadBtn)
expect(mockOnSelectVideoForImport).toHaveBeenCalledWith(videoAsset)
expect(mockOnImportRaw).not.toHaveBeenCalled()
})
it('FileCardItem renders sp-icon-link when isLinked is false, and triggers onLinkSequence on click', () => {
const mockOnLinkSequence = vi.fn()
const { container } = render(
<FileCardItem
asset={videoAsset}
onClick={mockOnClick}
onLinkSequence={mockOnLinkSequence}
isLinked={false}
/>,
)
const linkIcon = container.querySelector('sp-icon-link')
const unlinkIcon = container.querySelector('sp-icon-unlink')
expect(linkIcon).toBeTruthy()
expect(unlinkIcon).toBeNull()
const linkBtn = screen.getByTitle('Link to Sequence')
expect(linkBtn).toBeTruthy()
fireEvent.click(linkBtn)
expect(mockOnLinkSequence).toHaveBeenCalledWith(videoAsset)
})
it('FileCardItem renders sp-icon-unlink when isLinked is true, and triggers onUnlinkSequence on click', () => {
const mockOnLinkSequence = vi.fn()
const mockOnUnlinkSequence = vi.fn()
const { container } = render(
<FileCardItem
asset={videoAsset}
onClick={mockOnClick}
onLinkSequence={mockOnLinkSequence}
onUnlinkSequence={mockOnUnlinkSequence}
isLinked={true}
linkedSequenceName="Cut_v1"
/>,
)
const linkIcon = container.querySelector('sp-icon-link')
const unlinkIcon = container.querySelector('sp-icon-unlink')
expect(linkIcon).toBeNull()
expect(unlinkIcon).toBeTruthy()
const unlinkBtn = screen.getByTitle('Unlink from Cut_v1')
expect(unlinkBtn).toBeTruthy()
fireEvent.click(unlinkBtn)
expect(mockOnUnlinkSequence).toHaveBeenCalledWith(videoAsset)
expect(mockOnLinkSequence).not.toHaveBeenCalled()
})
it('FileItem renders sp-icon-unlink when isLinked is true', () => {
const mockOnLinkSequence = vi.fn()
const mockOnUnlinkSequence = vi.fn()
const { container } = render(
<FileItem
asset={videoAsset}
onClick={mockOnClick}
onLinkSequence={mockOnLinkSequence}
onUnlinkSequence={mockOnUnlinkSequence}
isLinked={true}
linkedSequenceName="Cut_v1"
/>,
)
const linkIcon = container.querySelector('sp-icon-link')
const unlinkIcon = container.querySelector('sp-icon-unlink')
expect(linkIcon).toBeNull()
expect(unlinkIcon).toBeTruthy()
const unlinkBtn = screen.getByTitle('Unlink from Cut_v1')
expect(unlinkBtn).toBeTruthy()
fireEvent.click(unlinkBtn)
expect(mockOnUnlinkSequence).toHaveBeenCalledWith(videoAsset)
})
it('FileCardItem renders version in details when asset has versionStack', () => {
const versionedAsset: AssetSummary = {
id: 'vid-v2',
name: 'interview_cut.mp4',
type: 'file',
mimeType: 'video/mp4',
sizeByte: 20 * 1024 * 1024,
versionStack: {
id: 'stack-1',
versions: [
{ version: 2, current: true, id: 'vid-v2', name: 'interview_cut.mp4' },
{ version: 1, current: false, id: 'vid-v1', name: 'interview_cut_v1.mp4' },
],
},
}
render(<FileCardItem asset={versionedAsset} onClick={mockOnClick} />)
expect(screen.getByText('v2')).toBeTruthy()
})
it('FileCardItem does not render version when asset has no versionStack', () => {
render(<FileCardItem asset={videoAsset} onClick={mockOnClick} />)
expect(screen.queryByText(/^v\d+$/)).toBeNull()
})
it('FileItem renders version in subtext when asset has versionStack', () => {
const versionedAsset: AssetSummary = {
id: 'vid-v2',
name: 'interview_cut.mp4',
type: 'file',
mimeType: 'video/mp4',
sizeByte: 20 * 1024 * 1024,
versionStack: {
id: 'stack-1',
versions: [
{ version: 2, current: true, id: 'vid-v2', name: 'interview_cut.mp4' },
{ version: 1, current: false, id: 'vid-v1', name: 'interview_cut_v1.mp4' },
],
},
}
render(<FileItem asset={versionedAsset} onClick={mockOnClick} />)
expect(screen.getByText(/v2 •/)).toBeTruthy()
})
it('FileCardItem renders createdAt time when provided', () => {
const assetWithDates: AssetSummary = {
id: 'date-1',
name: 'render.mp4',
type: 'file',
createdAt: new Date(Date.now() - 3600 * 1000).toISOString(),
updatedAt: new Date(Date.now() - 60 * 1000).toISOString(),
}
render(<FileCardItem asset={assetWithDates} onClick={mockOnClick} />)
expect(screen.getByText('1h ago')).toBeTruthy()
expect(screen.queryByText('1m ago')).toBeNull()
})
it('FileCardItem falls back to updatedAt if createdAt is absent', () => {
const assetWithUpdatedOnly: AssetSummary = {
id: 'date-2',
name: 'render2.mp4',
type: 'file',
updatedAt: new Date(Date.now() - 60 * 1000).toISOString(),
}
render(<FileCardItem asset={assetWithUpdatedOnly} onClick={mockOnClick} />)
expect(screen.getByText('1m ago')).toBeTruthy()
})
it('FileItem renders createdAt time in subtext when provided', () => {
const assetWithDates: AssetSummary = {
id: 'date-3',
name: 'render3.mp4',
type: 'file',
createdAt: new Date(Date.now() - 3600 * 1000).toISOString(),
updatedAt: new Date(Date.now() - 60 * 1000).toISOString(),
}
render(<FileItem asset={assetWithDates} onClick={mockOnClick} />)
expect(screen.getByText(/1h ago/)).toBeTruthy()
expect(screen.queryByText(/1m ago/)).toBeNull()
})
})
describe('getAssetVersionLabel', () => {
it('returns null for folder asset', () => {
const folder: AssetSummary = {
id: 'f1',
name: 'Footage',
type: 'folder',
}
expect(getAssetVersionLabel(folder)).toBeNull()
})
it('returns null for standalone file without versionStack', () => {
const file: AssetSummary = {
id: 'file1',
name: 'clip.mp4',
type: 'file',
}
expect(getAssetVersionLabel(file)).toBeNull()
})
it('returns null when versionStack has empty versions array', () => {
const file: AssetSummary = {
id: 'file1',
name: 'clip.mp4',
type: 'file',
versionStack: {
id: 'stack-1',
versions: [],
},
}
expect(getAssetVersionLabel(file)).toBeNull()
})
it('returns formatted version matching asset id', () => {
const file: AssetSummary = {
id: 'ver-1',
name: 'cut.mov',
type: 'file',
versionStack: {
id: 'stack-1',
versions: [
{ version: 3, current: false, id: 'ver-3' },
{ version: 2, current: false, id: 'ver-2' },
{ version: 1, current: false, id: 'ver-1' },
],
},
}
expect(getAssetVersionLabel(file)).toBe('v1')
})
it('returns current version when asset id is stack id or does not match', () => {
const file: AssetSummary = {
id: 'stack-1',
name: 'cut.mov',
type: 'version_stack',
versionStack: {
id: 'stack-1',
versions: [
{ version: 3, current: true, id: 'ver-3' },
{ version: 2, current: false, id: 'ver-2' },
{ version: 1, current: false, id: 'ver-1' },
],
},
}
expect(getAssetVersionLabel(file)).toBe('v3')
})
})
@@ -0,0 +1,503 @@
import React, { useState } from 'react'
import { formatDateAgo } from '../utils/date'
import { formatBytes, formatDuration } from '../utils/format'
import { resolveAssetUrl } from '../utils/url'
export { formatBytes, formatDuration }
export interface AssetSummary {
id: string
name: string
type: string
size?: number | null
sizeByte?: number | null
mimeType?: string | null
updatedAt?: string | Date
createdAt?: string | Date
commentsCount?: number
fileCount?: number
creator?: {
id: string
name: string
image?: string | null
} | null
agent?: {
id: string
name: string
} | null
preview?: {
thumbnailUrl?: string
duration?: number
pageCount?: number
proxyType?: string | null
} | null
media?: {
original?: {
key?: string
filesizeInBytes?: number
codec?: string
} | null
metadata?: {
duration?: number
}
videoTranscodes?: Array<{
id: string
url: string
key: string
width: number
height: number
size: number
}>
} | null
versionStack?: {
id: string
versions: Array<{
version: number
current: boolean
id: string
name?: string | null
createdAt?: string | null
previewUrl?: string | null
}>
} | null
}
export interface FileItemProps {
asset: AssetSummary
endpoint?: string
apiKey?: string
onClick: (e: React.MouseEvent) => void
onImportRaw?: (asset: AssetSummary) => void
onSelectVideoForImport?: (asset: AssetSummary) => void
onLinkSequence?: (asset: AssetSummary) => void
onUnlinkSequence?: (asset: AssetSummary) => void
isLinked?: boolean
linkedSequenceName?: string
}
export function getFileTypeCategory(
asset: AssetSummary,
): 'folder' | 'video' | 'audio' | 'image' | 'file' {
if (asset.type === 'folder') return 'folder'
const name = asset.name.toLowerCase()
const mime = asset.mimeType?.toLowerCase() || ''
if (mime.startsWith('video/') || /\.(mp4|mov|avi|mkv|m4v|webm)$/.test(name)) {
return 'video'
}
if (mime.startsWith('audio/') || /\.(mp3|wav|aac|flac|m4a|ogg)$/.test(name)) {
return 'audio'
}
if (mime.startsWith('image/') || /\.(png|jpg|jpeg|gif|webp|svg|bmp)$/.test(name)) {
return 'image'
}
return 'file'
}
export function getAssetVersionLabel(asset: AssetSummary): string | null {
if (asset.versionStack?.versions && asset.versionStack.versions.length > 0) {
const matched = asset.versionStack.versions.find((v) => v.id === asset.id)
if (matched?.version != null) {
return `v${matched.version}`
}
const current = asset.versionStack.versions.find((v) => v.current)
if (current?.version != null) {
return `v${current.version}`
}
const first = asset.versionStack.versions[0]
if (first?.version != null) {
return `v${first.version}`
}
return `v${asset.versionStack.versions.length}`
}
return null
}
/** List View Row Item */
export const FileItem: React.FC<FileItemProps> = ({
asset,
endpoint = '',
onClick,
onImportRaw,
onSelectVideoForImport,
onLinkSequence,
onUnlinkSequence,
isLinked = false,
linkedSequenceName,
}) => {
const [imgError, setImgError] = useState(false)
const category = getFileTypeCategory(asset)
const isFolder = category === 'folder'
const versionLabel = getAssetVersionLabel(asset)
const effectiveSize = asset.sizeByte ?? asset.size
const timeText = formatDateAgo(asset.createdAt || asset.updatedAt)
const thumbUrl = resolveAssetUrl(asset.preview?.thumbnailUrl, endpoint)
const iconFallback = (
<div className={`item-icon ${category}`}>
{category === 'folder' && (
<sp-icon-folder size="s" style={{ color: '#fbbf24' }}></sp-icon-folder>
)}
{category === 'video' && (
<sp-icon-filmstrip size="s" style={{ color: '#60a5fa' }}></sp-icon-filmstrip>
)}
{category === 'audio' && (
<sp-icon-audio size="s" style={{ color: '#a78bfa' }}></sp-icon-audio>
)}
{category === 'image' && (
<sp-icon-image size="s" style={{ color: '#f472b6' }}></sp-icon-image>
)}
{category === 'file' && (
<sp-icon-document size="s" style={{ color: '#999999' }}></sp-icon-document>
)}
</div>
)
const handleImportAction = () => {
if (isFolder) return
if (category === 'video' && onSelectVideoForImport) {
onSelectVideoForImport(asset)
} else if (onImportRaw) {
onImportRaw(asset)
}
}
const handleRowClick = (e: React.MouseEvent) => {
if (isFolder) {
onClick(e)
} else {
e.stopPropagation()
handleImportAction()
}
}
return (
<div
className="item-row"
onClick={handleRowClick}
role="button"
tabIndex={0}
onKeyDown={(e) => {
if (e.key === 'Enter' || e.key === ' ') {
e.preventDefault()
handleRowClick(e as unknown as React.MouseEvent)
}
}}
>
<div className="item-left">
{thumbUrl && !isFolder && !imgError ? (
<div className="item-thumb-wrapper">
<img
src={thumbUrl}
alt={asset.name}
className="item-thumb-img"
onLoad={() => console.log('[UXP Image OK]', thumbUrl)}
onError={() => {
console.error('[UXP Image Failed]', thumbUrl)
setImgError(true)
}}
/>
</div>
) : (
iconFallback
)}
<div className="item-meta">
<span className="item-name" title={asset.name}>
{asset.name}
</span>
<span className="item-subtext">
{versionLabel ? `${versionLabel} • ` : ''}
{isFolder ? 'Folder' : formatBytes(effectiveSize)}
{timeText ? ` • ${timeText}` : ''}
</span>
</div>
</div>
<div className="item-right">
{asset.commentsCount != null && asset.commentsCount > 0 && (
<span className="item-comments-count" title={`${asset.commentsCount} comments`}>
{asset.commentsCount} {asset.commentsCount === 1 ? 'comment' : 'comments'}
</span>
)}
{isFolder ? (
<sp-icon-chevron-right size="xs"></sp-icon-chevron-right>
) : (
<div style={{ display: 'flex', alignItems: 'center' }}>
{(onLinkSequence || onUnlinkSequence) &&
(category === 'video' || category === 'audio') && (
<sp-action-button
quiet
size="xs"
icon-only
label={
isLinked
? onUnlinkSequence
? `Unlink from ${linkedSequenceName || 'Sequence'}`
: `Linked to ${linkedSequenceName || 'Sequence'}`
: 'Link to Sequence'
}
title={
isLinked
? onUnlinkSequence
? `Unlink from ${linkedSequenceName || 'Sequence'}`
: `Linked to ${linkedSequenceName || 'Sequence'}`
: 'Link to Sequence'
}
className="item-row-link-btn"
style={{ marginRight: 4 }}
onClick={(e: React.MouseEvent) => {
e.stopPropagation()
if (isLinked && onUnlinkSequence) {
onUnlinkSequence(asset)
} else if (onLinkSequence) {
onLinkSequence(asset)
}
}}
>
{isLinked ? (
<sp-icon-unlink
size="s"
slot="icon"
style={{ color: '#f87171' }}
></sp-icon-unlink>
) : (
<sp-icon-link size="s" slot="icon"></sp-icon-link>
)}
</sp-action-button>
)}
{(onImportRaw || onSelectVideoForImport) && (
<sp-action-button
quiet
size="xs"
icon-only
label="Import into Premiere Pro"
title="Import into Premiere Pro"
className="item-row-import-btn"
onClick={(e: React.MouseEvent) => {
e.stopPropagation()
handleImportAction()
}}
>
<sp-icon-download size="s" slot="icon"></sp-icon-download>
</sp-action-button>
)}
</div>
)}
</div>
</div>
)
}
/** Card View Row Item (2 Columns: Left Preview, Right Info as Raw Text) */
export const FileCardItem: React.FC<FileItemProps> = ({
asset,
endpoint = '',
onClick,
onImportRaw,
onSelectVideoForImport,
onLinkSequence,
onUnlinkSequence,
isLinked = false,
linkedSequenceName,
}) => {
const [imgError, setImgError] = useState(false)
const category = getFileTypeCategory(asset)
const isFolder = category === 'folder'
const effectiveSize = asset.sizeByte ?? asset.size
const timeText = formatDateAgo(asset.createdAt || asset.updatedAt)
const thumbUrl = resolveAssetUrl(asset.preview?.thumbnailUrl, endpoint)
const duration = asset.preview?.duration ?? asset.media?.metadata?.duration
const durationText = formatDuration(duration)
const creatorName = asset.creator?.name || asset.agent?.name
const cardFallback = (
<div className={`file-row-placeholder ${category}`}>
{category === 'folder' && (
<sp-icon-folder size="l" style={{ color: '#fbbf24' }}></sp-icon-folder>
)}
{category === 'video' && (
<sp-icon-filmstrip size="l" style={{ color: '#60a5fa' }}></sp-icon-filmstrip>
)}
{category === 'audio' && (
<sp-icon-audio size="l" style={{ color: '#a78bfa' }}></sp-icon-audio>
)}
{category === 'image' && (
<sp-icon-image size="l" style={{ color: '#f472b6' }}></sp-icon-image>
)}
{category === 'file' && (
<sp-icon-document size="l" style={{ color: '#999999' }}></sp-icon-document>
)}
</div>
)
const handleImportAction = () => {
if (isFolder) return
if (category === 'video' && onSelectVideoForImport) {
onSelectVideoForImport(asset)
} else if (onImportRaw) {
onImportRaw(asset)
}
}
const handleCardClick = (e: React.MouseEvent) => {
if (isFolder) {
onClick(e)
}
}
// Assemble raw text details for Line 3 (Version • Duration • Size/Type • Comments)
const details: string[] = []
const versionLabel = getAssetVersionLabel(asset)
if (versionLabel) {
details.push(versionLabel)
}
if (durationText) {
details.push(durationText)
}
if (isFolder) {
details.push(asset.fileCount != null ? `${asset.fileCount} items` : 'Folder')
} else if (effectiveSize != null) {
details.push(formatBytes(effectiveSize))
}
if (asset.commentsCount != null && asset.commentsCount > 0) {
details.push(`${asset.commentsCount} ${asset.commentsCount === 1 ? 'comment' : 'comments'}`)
}
if (isLinked) {
details.push(`Linked: ${linkedSequenceName || 'Sequence'}`)
}
return (
<div
className={`file-row-card ${isFolder ? 'is-folder' : 'is-file'}`}
onClick={isFolder ? handleCardClick : undefined}
role={isFolder ? 'button' : undefined}
tabIndex={isFolder ? 0 : undefined}
title={isFolder ? asset.name : undefined}
onKeyDown={
isFolder
? (e) => {
if (e.key === 'Enter' || e.key === ' ') {
e.preventDefault()
handleCardClick(e as unknown as React.MouseEvent)
}
}
: undefined
}
>
{/* Left Column: Preview Only (NO LABELS, NO BADGES) */}
<div className="file-row-preview">
{thumbUrl && !isFolder && !imgError ? (
<img
src={thumbUrl}
alt={asset.name}
className="file-row-img"
onError={() => setImgError(true)}
/>
) : (
cardFallback
)}
</div>
{/* Right Column: Title, Creator & Date, Duration / Size / Comments as Raw Text */}
<div className="file-row-content">
<div className="file-row-header">
<span className="file-row-title" title={isFolder ? asset.name : undefined}>
{asset.name}
</span>
</div>
{(creatorName || timeText) && (
<div className="file-row-meta">
{creatorName && <span className="file-row-creator">{creatorName}</span>}
{creatorName && timeText && <span className="file-row-meta-dot">•</span>}
{timeText && <span className="file-row-time">{timeText}</span>}
</div>
)}
{details.length > 0 && (
<div className="file-row-subtext file-row-details">
{details.map((item, idx) => (
<React.Fragment key={idx}>
{idx > 0 && <span className="file-row-meta-dot">•</span>}
<span
className={`file-row-detail-item${item === versionLabel ? ' file-row-version' : ''}`}
>
{item}
</span>
</React.Fragment>
))}
</div>
)}
</div>
{/* Far Right Action Column (Centered Vertically across the card) */}
<div className="file-row-actions" style={{ display: 'flex', alignItems: 'center' }}>
{isFolder ? (
<sp-icon-chevron-right size="xs" className="file-row-chevron"></sp-icon-chevron-right>
) : (
<>
{(onLinkSequence || onUnlinkSequence) &&
(category === 'video' || category === 'audio') && (
<sp-action-button
quiet
size="xs"
icon-only
label={
isLinked
? onUnlinkSequence
? `Unlink from ${linkedSequenceName || 'Sequence'}`
: `Linked to ${linkedSequenceName || 'Sequence'}`
: 'Link to Sequence'
}
title={
isLinked
? onUnlinkSequence
? `Unlink from ${linkedSequenceName || 'Sequence'}`
: `Linked to ${linkedSequenceName || 'Sequence'}`
: 'Link to Sequence'
}
className="file-row-link-btn"
style={{ marginRight: 4 }}
onClick={(e: React.MouseEvent) => {
e.stopPropagation()
if (isLinked && onUnlinkSequence) {
onUnlinkSequence(asset)
} else if (onLinkSequence) {
onLinkSequence(asset)
}
}}
>
{isLinked ? (
<sp-icon-unlink
size="s"
slot="icon"
style={{ color: '#f87171' }}
></sp-icon-unlink>
) : (
<sp-icon-link size="s" slot="icon"></sp-icon-link>
)}
</sp-action-button>
)}
{(onImportRaw || onSelectVideoForImport) && (
<sp-action-button
quiet
size="xs"
icon-only
label="Import into Premiere Pro"
title="Import into Premiere Pro"
className="file-row-import-btn"
onClick={(e: React.MouseEvent) => {
e.stopPropagation()
handleImportAction()
}}
>
<sp-icon-download size="s" slot="icon"></sp-icon-download>
</sp-action-button>
)}
</>
)}
</div>
</div>
)
}
@@ -0,0 +1,59 @@
import React from 'react'
import { Divider } from '@swc-react/divider'
import { ShumaiLogo } from './icons'
interface HeaderProps {
endpoint?: string
onDisconnect?: () => void
}
export const Header: React.FC<HeaderProps> = ({ endpoint, onDisconnect }) => {
let displayHost = ''
if (endpoint) {
try {
const url = new URL(endpoint)
displayHost = url.host
} catch {
displayHost = endpoint
}
}
return (
<>
<header className="app-header">
<div className="logo-group">
<div className="logo-icon">
<ShumaiLogo width={18} height={18} />
</div>
<span className="app-title">Shumai</span>
</div>
{endpoint && onDisconnect && (
<div className="actions-group">
<div
className="header-status"
title={`Connected to ${endpoint}`}
role="status"
aria-label={`Connected to ${displayHost}`}
>
<span className="status-dot positive" />
<span className="status-text">{displayHost}</span>
</div>
<sp-button
quiet
variant="secondary"
size="s"
label="Disconnect / Change Server"
icon-only
onClick={onDisconnect}
title="Disconnect / Change Server"
>
<sp-icon-log-out slot="icon" size="s"></sp-icon-log-out>
</sp-button>
</div>
)}
</header>
<Divider size="s" />
</>
)
}
@@ -0,0 +1,162 @@
// @vitest-environment happy-dom
import React, { act } from 'react'
import { describe, it, expect, vi, afterEach } from 'vitest'
import { render, screen, fireEvent, cleanup } from '@testing-library/react'
import { ImportVideoDialog } from './ImportVideoDialog'
import type { AssetSummary } from './FileItem'
import * as importService from '../services/import'
// Configure React 19 act environment for happy-dom
;(globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true
describe('ImportVideoDialog Component', () => {
const mockOnClose = vi.fn()
const mockOnImportRaw = vi.fn()
const mockOnImportProxy = vi.fn()
const videoAsset: AssetSummary = {
id: 'asset-vid-1',
name: 'interview_clip.mp4',
type: 'file',
mimeType: 'video/mp4',
sizeByte: 1024 * 1024 * 45,
preview: {
duration: 154,
},
}
afterEach(() => {
cleanup()
vi.clearAllMocks()
})
it('renders nothing when closed or asset is null', () => {
const { container } = render(
<ImportVideoDialog
asset={videoAsset}
endpoint="https://api.shumai.test"
apiKey="test-key"
isOpen={false}
onClose={mockOnClose}
onImportRaw={mockOnImportRaw}
onImportProxy={mockOnImportProxy}
/>,
)
expect(container.firstChild).toBeNull()
const { container: containerNull } = render(
<ImportVideoDialog
asset={null}
endpoint="https://api.shumai.test"
apiKey="test-key"
isOpen={true}
onClose={mockOnClose}
onImportRaw={mockOnImportRaw}
onImportProxy={mockOnImportProxy}
/>,
)
expect(containerNull.firstChild).toBeNull()
})
it('renders video info and selects original file by default', async () => {
vi.spyOn(importService, 'fetchVideoProxies').mockResolvedValue([])
await act(async () => {
render(
<ImportVideoDialog
asset={videoAsset}
endpoint="https://api.shumai.test"
apiKey="test-key"
isOpen={true}
onClose={mockOnClose}
onImportRaw={mockOnImportRaw}
onImportProxy={mockOnImportProxy}
/>,
)
})
expect(screen.getByText('Import Video')).toBeTruthy()
expect(screen.getByText('interview_clip.mp4')).toBeTruthy()
expect(screen.getByText('Original File')).toBeTruthy()
expect(screen.getByText('No proxy transcodes available for this video.')).toBeTruthy()
// Click Import button
const importBtn = screen.getByText('Import')
fireEvent.click(importBtn)
expect(mockOnImportRaw).toHaveBeenCalledWith(videoAsset)
expect(mockOnClose).toHaveBeenCalled()
})
it('fetches and allows selecting a proxy transcode', async () => {
vi.spyOn(importService, 'fetchVideoProxies').mockResolvedValue([
{
id: 'proxy-1',
label: '1080p (MP4)',
resolution: '1080p',
url: 'https://cdn.shumai.test/1080p.mp4',
key: 'proxies/1080p.mp4',
width: 1920,
height: 1080,
size: 1024 * 1024 * 12,
},
])
await act(async () => {
render(
<ImportVideoDialog
asset={videoAsset}
endpoint="https://api.shumai.test"
apiKey="test-key"
isOpen={true}
onClose={mockOnClose}
onImportRaw={mockOnImportRaw}
onImportProxy={mockOnImportProxy}
/>,
)
})
expect(screen.getByText('1080p (MP4)')).toBeTruthy()
// Select the proxy card
const proxyCard = screen.getByText('1080p (MP4)')
fireEvent.click(proxyCard)
// Click Import button
const importBtn = screen.getByText('Import')
fireEvent.click(importBtn)
expect(mockOnImportProxy).toHaveBeenCalledWith(
videoAsset,
expect.objectContaining({ id: 'proxy-1', label: '1080p (MP4)' }),
)
expect(mockOnClose).toHaveBeenCalled()
})
it('closes on Escape key or cancel button', async () => {
vi.spyOn(importService, 'fetchVideoProxies').mockResolvedValue([])
await act(async () => {
render(
<ImportVideoDialog
asset={videoAsset}
endpoint="https://api.shumai.test"
apiKey="test-key"
isOpen={true}
onClose={mockOnClose}
onImportRaw={mockOnImportRaw}
onImportProxy={mockOnImportProxy}
/>,
)
})
const cancelBtn = screen.getByText('Cancel')
fireEvent.click(cancelBtn)
expect(mockOnClose).toHaveBeenCalledTimes(1)
act(() => {
fireEvent.keyDown(document, { key: 'Escape' })
})
expect(mockOnClose).toHaveBeenCalledTimes(2)
})
})
@@ -0,0 +1,245 @@
import React, { useState, useEffect, useCallback } from 'react'
import type { AssetSummary } from './FileItem'
import { fetchVideoProxies, type ProxyOption } from '../services/import'
import { formatBytes, formatDuration } from '../utils/format'
import { resolveAssetUrl } from '../utils/url'
import { ProgressCircle } from '@swc-react/progress-circle'
export interface ImportVideoDialogProps {
asset: AssetSummary | null
endpoint: string
apiKey: string
isOpen: boolean
onClose: () => void
onImportRaw: (asset: AssetSummary) => void
onImportProxy: (asset: AssetSummary, proxy: ProxyOption) => void
}
export const ImportVideoDialog: React.FC<ImportVideoDialogProps> = ({
asset,
endpoint,
apiKey,
isOpen,
onClose,
onImportRaw,
onImportProxy,
}) => {
const [selectedVersion, setSelectedVersion] = useState<'raw' | string>('raw')
const [proxies, setProxies] = useState<ProxyOption[]>([])
const [loadingProxies, setLoadingProxies] = useState(false)
const [thumbError, setThumbError] = useState(false)
// Reset and fetch proxies when a new video asset is opened
useEffect(() => {
if (!isOpen || !asset) {
setProxies([])
setSelectedVersion('raw')
setLoadingProxies(false)
setThumbError(false)
return
}
let isMounted = true
setLoadingProxies(true)
setSelectedVersion('raw')
void fetchVideoProxies(endpoint, apiKey, asset.id)
.then((items) => {
if (isMounted) {
setProxies(items)
}
})
.catch((err) => {
console.warn('Failed to load video proxies:', err)
})
.finally(() => {
if (isMounted) {
setLoadingProxies(false)
}
})
return () => {
isMounted = false
}
}, [isOpen, asset, endpoint, apiKey])
// Handle Escape key to close dialog
useEffect(() => {
if (!isOpen) return
const handleKeyDown = (e: KeyboardEvent) => {
if (e.key === 'Escape') {
onClose()
}
}
document.addEventListener('keydown', handleKeyDown)
return () => {
document.removeEventListener('keydown', handleKeyDown)
}
}, [isOpen, onClose])
const handleConfirm = useCallback(() => {
if (!asset) return
if (selectedVersion === 'raw') {
onClose()
onImportRaw(asset)
} else if (selectedVersion.startsWith('proxy:')) {
const proxyId = selectedVersion.slice('proxy:'.length)
const targetProxy = proxies.find((p) => p.id === proxyId)
if (targetProxy) {
onClose()
onImportProxy(asset, targetProxy)
}
}
}, [asset, selectedVersion, proxies, onClose, onImportRaw, onImportProxy])
if (!isOpen || !asset) return null
const effectiveSize = asset.sizeByte ?? asset.size
const thumbUrl = resolveAssetUrl(asset.preview?.thumbnailUrl, endpoint)
const duration = asset.preview?.duration ?? asset.media?.metadata?.duration
const durationText = formatDuration(duration)
return (
<div
className="shumai-dialog-backdrop"
onClick={(e) => {
if (e.target === e.currentTarget) {
onClose()
}
}}
>
<div className="shumai-dialog" role="dialog" aria-modal="true" aria-labelledby="dialog-title">
{/* Dialog Header */}
<div className="shumai-dialog-header">
<span id="dialog-title" className="shumai-dialog-title">
Import Video
</span>
<button
type="button"
className="shumai-dialog-close"
onClick={onClose}
title="Close dialog"
aria-label="Close dialog"
>
<sp-icon-close size="s"></sp-icon-close>
</button>
</div>
{/* Video Asset Preview Info */}
<div className="shumai-dialog-asset-info">
<div className="shumai-dialog-thumb">
{thumbUrl && !thumbError ? (
<img src={thumbUrl} alt={asset.name} onError={() => setThumbError(true)} />
) : (
<sp-icon-filmstrip size="xxl" style={{ color: '#60a5fa' }}></sp-icon-filmstrip>
)}
</div>
<div className="shumai-dialog-asset-meta">
<span className="shumai-dialog-asset-name" title={asset.name}>
{asset.name}
</span>
<span className="shumai-dialog-asset-details">
{durationText ? `${durationText} • ` : ''}
{effectiveSize ? formatBytes(effectiveSize) : 'Video'}
</span>
</div>
</div>
{/* Options Selection Body */}
<div className="shumai-dialog-body">
<div className="shumai-dialog-section-label">Choose Version to Import</div>
{/* Original Version Card */}
<div
className={`shumai-option-card ${selectedVersion === 'raw' ? 'selected' : ''}`}
onClick={() => setSelectedVersion('raw')}
role="radio"
aria-checked={selectedVersion === 'raw'}
tabIndex={0}
onKeyDown={(e) => {
if (e.key === 'Enter' || e.key === ' ') {
e.preventDefault()
setSelectedVersion('raw')
}
}}
>
<div className="shumai-option-left">
<div className="shumai-option-texts">
<span className="shumai-option-title">Original File</span>
<span className="shumai-option-meta">
Full resolution • {effectiveSize ? formatBytes(effectiveSize) : 'Raw file'}
</span>
</div>
</div>
<div className="shumai-option-radio">
{selectedVersion === 'raw' && <div className="shumai-option-radio-dot" />}
</div>
</div>
<div className="shumai-dialog-divider" />
{/* Proxies Section */}
<div className="shumai-dialog-section-label">Transcode Proxies</div>
{loadingProxies ? (
<div className="shumai-dialog-loading">
<ProgressCircle indeterminate size="s" label="Checking available proxies..." />
<span>Checking available proxies...</span>
</div>
) : proxies.length > 0 ? (
proxies.map((proxy) => {
const isSelected = selectedVersion === `proxy:${proxy.id}`
return (
<div
key={proxy.id}
className={`shumai-option-card ${isSelected ? 'selected' : ''}`}
onClick={() => setSelectedVersion(`proxy:${proxy.id}`)}
role="radio"
aria-checked={isSelected}
tabIndex={0}
onKeyDown={(e) => {
if (e.key === 'Enter' || e.key === ' ') {
e.preventDefault()
setSelectedVersion(`proxy:${proxy.id}`)
}
}}
>
<div className="shumai-option-left">
<div className="shumai-option-texts">
<span className="shumai-option-title">{proxy.label}</span>
<span className="shumai-option-meta">
{proxy.width && proxy.height ? `${proxy.width}x${proxy.height} • ` : ''}
{proxy.size ? `${formatBytes(proxy.size)} • ` : ''}
Fast editing proxy
</span>
</div>
</div>
<div className="shumai-option-radio">
{isSelected && <div className="shumai-option-radio-dot" />}
</div>
</div>
)
})
) : (
<div className="shumai-dialog-empty-proxies">
<span>No proxy transcodes available for this video.</span>
</div>
)}
</div>
{/* Dialog Footer Actions */}
<div className="shumai-dialog-footer">
<sp-button quiet variant="secondary" size="s" onClick={onClose}>
Cancel
</sp-button>
<sp-button variant="accent" size="s" onClick={handleConfirm}>
Import
</sp-button>
</div>
</div>
</div>
)
}
@@ -0,0 +1,194 @@
// @vitest-environment happy-dom
import React, { act } from 'react'
import { describe, it, expect, vi, afterEach, beforeEach } from 'vitest'
import { render, screen, fireEvent, cleanup } from '@testing-library/react'
import { LinkSequenceDialog } from './LinkSequenceDialog'
import type { AssetSummary } from './FileItem'
import * as premiereService from '../services/premiere'
import * as linkStorage from '../services/linkStorage'
import * as markersService from '../services/markers'
import type { Project, Sequence } from '@adobe/premierepro'
import type { CommentInfo } from '@shumai/dtos'
// Configure React 19 act environment for happy-dom
;(globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true
describe('LinkSequenceDialog Component', () => {
const mockOnClose = vi.fn()
const mockOnLinkSuccess = vi.fn()
const videoAsset: AssetSummary = {
id: 'asset-vid-1',
name: 'interview_clip.mp4',
type: 'file',
mimeType: 'video/mp4',
sizeByte: 1024 * 1024 * 45,
preview: {
duration: 154,
},
commentsCount: 3,
}
beforeEach(() => {
vi.restoreAllMocks()
})
afterEach(() => {
cleanup()
})
it('renders nothing when closed or asset is null', () => {
const { container } = render(
<LinkSequenceDialog
asset={videoAsset}
endpoint="https://api.shumai.test"
apiKey="test-key"
isOpen={false}
onClose={mockOnClose}
onLinkSuccess={mockOnLinkSuccess}
/>,
)
expect(container.firstChild).toBeNull()
const { container: containerNull } = render(
<LinkSequenceDialog
asset={null}
endpoint="https://api.shumai.test"
apiKey="test-key"
isOpen={true}
onClose={mockOnClose}
onLinkSuccess={mockOnLinkSuccess}
/>,
)
expect(containerNull.firstChild).toBeNull()
})
it('displays error message when no active project is open', async () => {
vi.spyOn(premiereService, 'getActiveProject').mockResolvedValue(null)
await act(async () => {
render(
<LinkSequenceDialog
asset={videoAsset}
endpoint="https://api.shumai.test"
apiKey="test-key"
isOpen={true}
onClose={mockOnClose}
onLinkSuccess={mockOnLinkSuccess}
/>,
)
})
expect(screen.getByText(/no active premiere pro project found/i)).toBeDefined()
})
it('lists project sequences and highlights active sequence without sequence icon', async () => {
const mockSeq1 = { guid: 'seq-1', name: 'Rough Cut' }
const mockSeq2 = { guid: 'seq-2', name: 'Fine Cut' }
const mockProject = { guid: 'proj-1' }
vi.spyOn(premiereService, 'getActiveProject').mockResolvedValue(
mockProject as unknown as Project,
)
vi.spyOn(premiereService, 'getAllSequences').mockResolvedValue([
mockSeq1,
mockSeq2,
] as unknown as Sequence[])
vi.spyOn(premiereService, 'getActiveSequence').mockResolvedValue(
mockSeq2 as unknown as Sequence,
)
vi.spyOn(linkStorage, 'getAllLinkedSequences').mockResolvedValue([])
let renderedContainer: HTMLElement = null!
await act(async () => {
const { container } = render(
<LinkSequenceDialog
asset={videoAsset}
endpoint="https://api.shumai.test"
apiKey="test-key"
isOpen={true}
onClose={mockOnClose}
onLinkSuccess={mockOnLinkSuccess}
/>,
)
renderedContainer = container
})
expect(screen.getByText('Rough Cut')).toBeDefined()
expect(screen.getByText('Fine Cut')).toBeDefined()
expect(screen.getByText('Active')).toBeDefined()
expect(renderedContainer.querySelectorAll('.shumai-option-card sp-icon-filmstrip').length).toBe(
0,
)
})
it('executes sync and invokes onLinkSuccess on confirmation', async () => {
const mockSeq1 = { guid: 'seq-1', name: 'Rough Cut' }
const mockProject = { guid: 'proj-1' }
vi.spyOn(premiereService, 'getActiveProject').mockResolvedValue(
mockProject as unknown as Project,
)
vi.spyOn(premiereService, 'getAllSequences').mockResolvedValue([
mockSeq1,
] as unknown as Sequence[])
vi.spyOn(premiereService, 'getActiveSequence').mockResolvedValue(
mockSeq1 as unknown as Sequence,
)
vi.spyOn(linkStorage, 'getAllLinkedSequences').mockResolvedValue([])
vi.spyOn(markersService, 'fetchAssetComments').mockResolvedValue([
{ id: 'comm-1', second: 10, message: 'Test marker' } as unknown as CommentInfo,
])
const mockUpdatedLink = {
sequenceGuid: 'seq-1',
sequenceName: 'Rough Cut',
assetId: 'asset-vid-1',
assetName: 'interview_clip.mp4',
syncedCommentIds: ['comm-1'],
lastSyncAt: Date.now(),
totalCommentsSynced: 1,
}
vi.spyOn(markersService, 'syncCommentsToSequence').mockResolvedValue({
updatedLink: mockUpdatedLink,
addedCount: 1,
})
await act(async () => {
render(
<LinkSequenceDialog
asset={videoAsset}
endpoint="https://api.shumai.test"
apiKey="test-key"
isOpen={true}
onClose={mockOnClose}
onLinkSuccess={mockOnLinkSuccess}
/>,
)
})
const linkBtn = screen.getByText('Link Sequence')
await act(async () => {
fireEvent.click(linkBtn)
})
expect(markersService.fetchAssetComments).toHaveBeenCalledWith(
'https://api.shumai.test',
'test-key',
'asset-vid-1',
)
expect(markersService.syncCommentsToSequence).toHaveBeenCalledWith(
mockProject,
mockSeq1,
expect.any(Array),
expect.objectContaining({
endpoint: 'https://api.shumai.test',
sequenceGuid: 'seq-1',
assetId: 'asset-vid-1',
}),
)
expect(mockOnLinkSuccess).toHaveBeenCalledWith(mockUpdatedLink, 1)
expect(mockOnClose).toHaveBeenCalled()
})
})
@@ -0,0 +1,420 @@
import React, { useState, useEffect, useCallback } from 'react'
import type { Sequence, Project } from '@adobe/premierepro'
import type { AssetSummary } from './FileItem'
import type { LinkedSequenceAsset } from '../types/link'
import { getActiveProject, getAllSequences, getActiveSequence } from '../services/premiere'
import { getAllLinkedSequences, normalizeGuid, removeSequenceLink } from '../services/linkStorage'
import { fetchAssetComments, syncCommentsToSequence } from '../services/markers'
import { resolveAssetUrl, isSameEndpoint } from '../utils/url'
import { formatBytes, formatDuration } from '../utils/format'
import { ProgressCircle } from '@swc-react/progress-circle'
export interface LinkSequenceDialogProps {
asset: AssetSummary | null
endpoint: string
apiKey: string
isOpen: boolean
onClose: () => void
onLinkSuccess: (link: LinkedSequenceAsset, addedMarkersCount: number) => void
}
interface SequenceOption {
sequence: Sequence
guid: string
name: string
isActive: boolean
currentLink: LinkedSequenceAsset | null
}
export const LinkSequenceDialog: React.FC<LinkSequenceDialogProps> = ({
asset,
endpoint,
apiKey,
isOpen,
onClose,
onLinkSuccess,
}) => {
const [project, setProject] = useState<Project | null>(null)
const [sequences, setSequences] = useState<SequenceOption[]>([])
const [selectedGuid, setSelectedGuid] = useState<string>('')
const [loadingSequences, setLoadingSequences] = useState(true)
const [linking, setLinking] = useState(false)
const [errorMessage, setErrorMessage] = useState<string | null>(null)
const [thumbError, setThumbError] = useState(false)
// Load project sequences and link states when opened
useEffect(() => {
if (!isOpen || !asset) {
setProject(null)
setSequences([])
setSelectedGuid('')
setErrorMessage(null)
setLinking(false)
setThumbError(false)
return
}
let isMounted = true
setLoadingSequences(true)
setErrorMessage(null)
async function loadProjectData() {
try {
const pr = await getActiveProject()
if (!isMounted) return
if (!pr) {
setProject(null)
setLoadingSequences(false)
setErrorMessage('No active Premiere Pro project found. Please open a project first.')
return
}
setProject(pr)
const [allSeqs, activeSeq, existingLinks] = await Promise.all([
getAllSequences(pr),
getActiveSequence(pr),
getAllLinkedSequences(pr),
])
if (!isMounted) return
if (!allSeqs || allSeqs.length === 0) {
setLoadingSequences(false)
setErrorMessage(
'No sequences found in the current project. Please create a sequence first.',
)
return
}
const activeGuid = normalizeGuid(activeSeq?.guid)
const linksMap = new Map<string, LinkedSequenceAsset>()
for (const link of existingLinks) {
if (!link.endpoint || isSameEndpoint(link.endpoint, endpoint)) {
linksMap.set(normalizeGuid(link.sequenceGuid), link)
}
}
const options: SequenceOption[] = allSeqs.map((seq) => {
const guidStr = normalizeGuid(seq.guid)
return {
sequence: seq,
guid: guidStr,
name: seq.name || 'Untitled Sequence',
isActive: Boolean(activeGuid && guidStr === activeGuid),
currentLink: linksMap.get(guidStr) || null,
}
})
setSequences(options)
// Pre-select active sequence if found, else first sequence
if (activeGuid && options.some((opt) => opt.guid === activeGuid)) {
setSelectedGuid(activeGuid)
} else if (options.length > 0) {
setSelectedGuid(options[0].guid)
}
} catch (err) {
if (!isMounted) return
console.error('[LinkSequenceDialog] Error loading project data:', err)
setErrorMessage('Failed to load project sequences from Premiere Pro.')
} finally {
if (isMounted) {
setLoadingSequences(false)
}
}
}
void loadProjectData()
return () => {
isMounted = false
}
}, [isOpen, asset, endpoint])
// Escape key handler
useEffect(() => {
if (!isOpen) return
const handleKeyDown = (e: KeyboardEvent) => {
if (e.key === 'Escape' && !linking) {
onClose()
}
}
document.addEventListener('keydown', handleKeyDown)
return () => {
document.removeEventListener('keydown', handleKeyDown)
}
}, [isOpen, linking, onClose])
const handleConfirm = useCallback(async () => {
if (!asset || !project || !selectedGuid || linking) return
const targetOption = sequences.find(
(opt) => normalizeGuid(opt.guid) === normalizeGuid(selectedGuid),
)
if (!targetOption) return
setLinking(true)
try {
// If sequence was linked to another asset, remove its previous link and markers first
if (targetOption.currentLink && targetOption.currentLink.assetId !== asset.id) {
await removeSequenceLink(project, targetOption.sequence)
}
// 1. Fetch timecoded comments for this asset
const comments = await fetchAssetComments(endpoint, apiKey, asset.id)
// 2. Prepare initial link metadata
const prGuidStr = project.guid ? normalizeGuid(project.guid) : undefined
const initialLink: LinkedSequenceAsset = {
sequenceGuid: normalizeGuid(targetOption.guid),
sequenceName: targetOption.name,
assetId: asset.id,
assetName: asset.name,
assetThumbnailUrl: asset.preview?.thumbnailUrl,
endpoint: endpoint.trim().replace(/\/+$/, ''),
projectId: prGuidStr,
syncedCommentIds:
targetOption.currentLink?.assetId === asset.id
? targetOption.currentLink.syncedCommentIds
: [],
syncedMarkerGuids:
targetOption.currentLink?.assetId === asset.id
? (targetOption.currentLink.syncedMarkerGuids || []).map(normalizeGuid)
: [],
lastSyncAt: Date.now(),
totalCommentsSynced:
targetOption.currentLink?.assetId === asset.id
? targetOption.currentLink.totalCommentsSynced
: 0,
}
// 3. Translate comments to markers on the sequence
const { updatedLink, addedCount } = await syncCommentsToSequence(
project,
targetOption.sequence,
comments,
initialLink,
)
onLinkSuccess(updatedLink, addedCount)
onClose()
} catch (err) {
console.error('[LinkSequenceDialog] Failed to link sequence:', err)
setErrorMessage('Failed to link sequence and sync markers. Please try again.')
} finally {
setLinking(false)
}
}, [asset, project, selectedGuid, linking, sequences, endpoint, apiKey, onLinkSuccess, onClose])
if (!isOpen || !asset) return null
const selectedOption = sequences.find((opt) => opt.guid === selectedGuid)
const isReplacingOtherAsset =
selectedOption?.currentLink && selectedOption.currentLink.assetId !== asset.id
const effectiveSize = asset.sizeByte ?? asset.size
const thumbUrl = resolveAssetUrl(asset.preview?.thumbnailUrl, endpoint)
const duration = asset.preview?.duration ?? asset.media?.metadata?.duration
const durationText = formatDuration(duration)
return (
<div
className="shumai-dialog-backdrop"
onClick={(e) => {
if (e.target === e.currentTarget && !linking) {
onClose()
}
}}
>
<div
className="shumai-dialog"
role="dialog"
aria-modal="true"
aria-labelledby="link-dialog-title"
>
{/* Header */}
<div className="shumai-dialog-header">
<div style={{ display: 'flex', alignItems: 'center' }}>
<sp-icon-link size="s" style={{ marginRight: 6, color: '#3b82f6' }}></sp-icon-link>
<span id="link-dialog-title" className="shumai-dialog-title">
Link to Sequence
</span>
</div>
<button
type="button"
className="shumai-dialog-close"
onClick={onClose}
disabled={linking}
title="Close dialog"
aria-label="Close dialog"
>
<sp-icon-close size="s"></sp-icon-close>
</button>
</div>
{/* Asset Info Card */}
<div className="shumai-dialog-asset-info">
<div className="shumai-dialog-thumb">
{thumbUrl && !thumbError ? (
<img src={thumbUrl} alt={asset.name} onError={() => setThumbError(true)} />
) : asset.type === 'video' ? (
<sp-icon-filmstrip size="xxl" style={{ color: '#60a5fa' }}></sp-icon-filmstrip>
) : asset.type === 'audio' ? (
<sp-icon-audio size="xxl" style={{ color: '#a78bfa' }}></sp-icon-audio>
) : (
<sp-icon-document size="xxl" style={{ color: '#999999' }}></sp-icon-document>
)}
</div>
<div className="shumai-dialog-asset-meta">
<span className="shumai-dialog-asset-name" title={asset.name}>
{asset.name}
</span>
<span className="shumai-dialog-asset-details">
{durationText ? `${durationText} • ` : ''}
{effectiveSize ? `${formatBytes(effectiveSize)} • ` : ''}
{asset.commentsCount != null && asset.commentsCount > 0
? `${asset.commentsCount} comments`
: 'No comments'}
</span>
</div>
</div>
{/* Dialog Body */}
<div className="shumai-dialog-body">
<div className="shumai-dialog-section-label">Select Sequence in Project</div>
{loadingSequences ? (
<div className="shumai-dialog-loading">
<ProgressCircle indeterminate size="s" label="Checking project sequences..." />
<span>Checking project sequences...</span>
</div>
) : errorMessage ? (
<div className="shumai-dialog-empty-proxies" style={{ color: '#f87171' }}>
<span>{errorMessage}</span>
</div>
) : sequences.length > 0 ? (
sequences.map((opt) => {
const isSelected = selectedGuid === opt.guid
const isLinkedToAnother = opt.currentLink && opt.currentLink.assetId !== asset.id
const isLinkedToThis = opt.currentLink && opt.currentLink.assetId === asset.id
return (
<div
key={opt.guid}
className={`shumai-option-card ${isSelected ? 'selected' : ''}`}
onClick={() => !linking && setSelectedGuid(opt.guid)}
role="radio"
aria-checked={isSelected}
tabIndex={0}
onKeyDown={(e) => {
if (e.key === 'Enter' || e.key === ' ') {
e.preventDefault()
if (!linking) setSelectedGuid(opt.guid)
}
}}
>
<div className="shumai-option-left">
<div className="shumai-option-texts">
<div style={{ display: 'flex', alignItems: 'center' }}>
<span className="shumai-option-title">{opt.name}</span>
{opt.isActive && (
<span
style={{
fontSize: '10px',
marginLeft: 6,
padding: '1px 5px',
borderRadius: '3px',
backgroundColor: 'rgba(59, 130, 246, 0.2)',
color: '#60a5fa',
fontWeight: 500,
}}
>
Active
</span>
)}
</div>
<span className="shumai-option-meta">
{isLinkedToThis ? (
<span style={{ color: '#34d399' }}>Already linked to this asset</span>
) : isLinkedToAnother ? (
<span style={{ color: '#fbbf24' }}>
Linked to &quot;{opt.currentLink?.assetName}&quot; (will replace)
</span>
) : (
'Ready to link'
)}
</span>
</div>
</div>
<div className="shumai-option-radio">
{isSelected && <div className="shumai-option-radio-dot" />}
</div>
</div>
)
})
) : (
<div className="shumai-dialog-empty-proxies">
<span>No sequences available in current project.</span>
</div>
)}
{isReplacingOtherAsset && (
<div
style={{
marginTop: 10,
padding: '8px 10px',
borderRadius: 4,
backgroundColor: 'rgba(245, 158, 11, 0.12)',
border: '1px solid rgba(245, 158, 11, 0.3)',
display: 'flex',
alignItems: 'center',
fontSize: 11,
color: '#fbbf24',
}}
>
<sp-icon-alert-triangle
size="s"
style={{ marginRight: 6, flexShrink: 0 }}
></sp-icon-alert-triangle>
<span>
This sequence is already linked to another asset. Proceeding will replace the link
and sync markers for this asset.
</span>
</div>
)}
<div style={{ marginTop: 12, fontSize: 11, color: 'var(--text-secondary)' }}>
Comments with timestamps will be placed on the sequence timeline as markers. Markers
deleted in Premiere Pro will not be re-synced.
</div>
</div>
{/* Footer */}
<div className="shumai-dialog-footer">
<sp-button quiet variant="secondary" size="s" onClick={onClose} disabled={linking}>
Cancel
</sp-button>
<sp-button
variant="accent"
size="s"
onClick={handleConfirm}
disabled={!selectedGuid || loadingSequences || Boolean(errorMessage) || linking}
>
{linking ? (
<>
<ProgressCircle indeterminate size="s" slot="icon" label="Linking..." />
Linking...
</>
) : isReplacingOtherAsset ? (
'Replace & Link'
) : (
'Link Sequence'
)}
</sp-button>
</div>
</div>
</div>
)
}
@@ -0,0 +1,33 @@
// @vitest-environment happy-dom
import React from 'react'
import { describe, it, expect, vi, afterEach } from 'vitest'
import { render, screen, fireEvent, cleanup } from '@testing-library/react'
import { NavigationTabs } from './NavigationTabs'
describe('NavigationTabs Component', () => {
afterEach(() => {
cleanup()
})
it('renders Sequences and Browse tabs with badge', () => {
const handleTabChange = vi.fn()
render(<NavigationTabs activeTab="sequences" onTabChange={handleTabChange} linkedCount={3} />)
expect(screen.getByText('Sequences')).toBeDefined()
expect(screen.getByText('Browse')).toBeDefined()
expect(screen.getByText('3')).toBeDefined()
})
it('handles tab click events', () => {
const handleTabChange = vi.fn()
render(<NavigationTabs activeTab="sequences" onTabChange={handleTabChange} linkedCount={0} />)
const browseTab = screen.getByText('Browse')
fireEvent.click(browseTab)
expect(handleTabChange).toHaveBeenCalledWith('browse')
const sequencesTab = screen.getByText('Sequences')
fireEvent.click(sequencesTab)
expect(handleTabChange).toHaveBeenCalledWith('sequences')
})
})
@@ -0,0 +1,44 @@
import React from 'react'
export type MainTab = 'sequences' | 'browse'
export interface NavigationTabsProps {
activeTab: MainTab
onTabChange: (tab: MainTab) => void
linkedCount?: number
}
export const NavigationTabs: React.FC<NavigationTabsProps> = ({
activeTab,
onTabChange,
linkedCount = 0,
}) => {
return (
<div className="shumai-nav-tabs-bar" role="tablist">
<sp-button
size="s"
variant={activeTab === 'sequences' ? 'accent' : 'secondary'}
treatment="fill"
onClick={() => onTabChange('sequences')}
className={`shumai-tab-sp-btn ${activeTab === 'sequences' ? 'active' : ''}`}
>
<span className="shumai-tab-label">Sequences</span>
{linkedCount > 0 && (
<span className="shumai-tab-badge" title={`${linkedCount} linked sequence assets`}>
{linkedCount}
</span>
)}
</sp-button>
<sp-button
size="s"
variant={activeTab === 'browse' ? 'accent' : 'secondary'}
treatment="fill"
onClick={() => onTabChange('browse')}
className={`shumai-tab-sp-btn ${activeTab === 'browse' ? 'active' : ''}`}
>
<span className="shumai-tab-label">Browse</span>
</sp-button>
</div>
)
}
@@ -0,0 +1,88 @@
import React, { useState } from 'react'
import { formatDateAgo } from '../utils/date'
import { resolveAssetUrl } from '../utils/url'
import type { ProjectSummary } from '../views/ProjectsView'
interface ProjectCardProps {
project: ProjectSummary
endpoint?: string
onClick: () => void
}
export const ShumaiPolygonCover: React.FC = () => (
<svg
xmlns="http://www.w3.org/2000/svg"
viewBox="0 0 180.95 164.7"
preserveAspectRatio="xMidYMid slice"
style={{ width: '100%', height: '100%', display: 'block' }}
>
<polygon fill="#FC9F8E" points="0 18.5 0 76.0 151.69 164.7 180.95 164.7 180.95 113.6" />
<polygon fill="#FEBAB8" points="0 0 74.58 61.5 90.53 51.6 110.33 63.9 180.95 18.9 180.95 0" />
<polyline
fill="#FAA5A5"
points="0 18.5 74.58 61.5 90.53 51.6 110.33 63.9 180.95 18.9 180.95 0 0 0"
/>
<polygon fill="#EC5B6C" points="0 76.0 0 164.7 151.69 164.7" />
<polygon fill="#E85C71" points="180.95 18.9 110.33 63.9 117.37 68.0 117.26 73.4 180.95 113.6" />
<polygon
fill="#C8405B"
points="117.26 73.4 117.37 99.0 90.53 114.9 174.35 164.7 180.95 164.7 180.95 113.6"
/>
<polygon fill="#FFCCBE" points="90.53 51.6 63.69 68.1 90.53 83.4" />
<path
fill="#FB9991"
d="M 90.53 51.6 L 90.53 61.3 L 100.87 67.4 L 90.53 73.5 L 90.53 83.4 L 117.37 68.0 C 117.15 67.6 90.53 51.6 90.53 51.6 Z"
/>
<path
fill="#FFEACD"
d="M 63.69 68.1 C 63.47 68.5 64.02 99.3 64.02 99.3 C 64.02 99.3 64.46 99.6 64.9 99.9 L 90.53 83.4 L 63.69 68.1 Z"
/>
<polygon fill="#FFCFB5" points="64.02 99.3 90.53 114.9 90.53 83.4" />
<path fill="#F67D73" d="M 90.53 83.4 L 90.53 114.9 L 117.37 99.0 Z" />
<path fill="#F26560" d="M 90.53 83.4 L 117.37 99.0 L 117.37 68.0 Z" />
<polygon fill="#EB5F5B" points="80.08 67.5 90.53 73.5 90.53 61.3" />
<polygon fill="#DB4D50" points="90.53 61.3 90.53 73.5 100.87 67.4" />
</svg>
)
export const ProjectCard: React.FC<ProjectCardProps> = ({ project, endpoint, onClick }) => {
const [imgError, setImgError] = useState(false)
const updatedText = formatDateAgo(project.updatedAt)
const coverUrl = resolveAssetUrl(project.coverImage, endpoint)
return (
<div
className="project-row-card"
onClick={onClick}
role="button"
tabIndex={0}
title={project.name}
onKeyDown={(e) => {
if (e.key === 'Enter' || e.key === ' ') {
e.preventDefault()
onClick()
}
}}
>
<div className="project-row-preview">
{coverUrl && !imgError ? (
<img
src={coverUrl}
alt={project.name}
className="project-row-img"
onError={() => setImgError(true)}
/>
) : (
<ShumaiPolygonCover />
)}
</div>
<div className="project-row-content">
<span className="project-row-title">{project.name}</span>
<span className="project-row-subtext">
{updatedText ? `Updated ${updatedText}` : 'Project'}
</span>
</div>
</div>
)
}
@@ -0,0 +1,41 @@
import React from 'react'
export const ShumaiLogo: React.FC<React.SVGProps<SVGSVGElement>> = (props) => {
return (
<svg viewBox="0 0 100 100" fill="none" xmlns="http://www.w3.org/2000/svg" {...props}>
<defs>
<clipPath id="bg-clip">
<rect x="5" y="5" width="90" height="90" rx="22" />
</clipPath>
</defs>
{/* Background */}
<rect x="5" y="5" width="90" height="90" rx="22" fill="#D95A66" />
{/* Long Shadow */}
<path
d="M 35 75 L 65 75 L 80 60 L 75 30 L 175 130 L 135 175 Z"
fill="#A8384D"
clipPath="url(#bg-clip)"
/>
{/* Left Cream */}
<path d="M 25 30 Q 38 36 50 42 L 35 55 L 35 75 L 20 60 Z" fill="#FDF0D5" />
{/* Right Orange */}
<path d="M 50 42 Q 62 36 75 30 L 80 60 L 65 75 L 65 55 Z" fill="#E77A65" />
{/* Front Peach */}
<path d="M 35 75 L 65 75 L 65 55 L 50 42 L 35 55 Z" fill="#F5B895" />
{/* Top Pink */}
<path d="M 50 42 Q 38 36 25 30 Q 38 26 50 20 Q 62 26 75 30 Q 62 36 50 42 Z" fill="#F4B8B8" />
{/* Hole Left */}
<path d="M 50 25 L 42 30 L 50 35 Z" fill="#E57A5F" />
{/* Hole Right */}
<path d="M 50 25 L 58 30 L 50 35 Z" fill="#C2523C" />
</svg>
)
}
+299
View File
@@ -0,0 +1,299 @@
/* eslint-disable @typescript-eslint/naming-convention -- Custom element tag names in IntrinsicElements require hyphens */
declare module '@swc-uxp-wrappers/utils' {
export const aliases: Record<string, string>
}
type SpIconCustomElementProps = import('react').DetailedHTMLProps<
import('react').HTMLAttributes<HTMLElement>,
HTMLElement
> & {
size?: 'xxs' | 'xs' | 's' | 'm' | 'l' | 'xl' | 'xxl'
slot?: string
name?: string
label?: string
}
type SpButtonCustomElementProps = import('react').DetailedHTMLProps<
import('react').ButtonHTMLAttributes<HTMLButtonElement>,
HTMLButtonElement
> & {
variant?: 'accent' | 'primary' | 'secondary' | 'negative' | 'white' | 'black' | string
treatment?: 'fill' | 'outline' | string
quiet?: boolean
size?: 'xs' | 's' | 'm' | 'l' | 'xl'
label?: string
'icon-only'?: boolean
disabled?: boolean
slot?: string
}
type SpButtonGroupCustomElementProps = import('react').DetailedHTMLProps<
import('react').HTMLAttributes<HTMLElement>,
HTMLElement
> & {
vertical?: boolean
size?: 'xs' | 's' | 'm' | 'l' | 'xl'
}
type SpActionButtonCustomElementProps = import('react').DetailedHTMLProps<
import('react').ButtonHTMLAttributes<HTMLButtonElement>,
HTMLButtonElement
> & {
quiet?: boolean
size?: 'xs' | 's' | 'm' | 'l' | 'xl'
label?: string
disabled?: boolean
selected?: boolean
toggles?: boolean
emphasized?: boolean
slot?: string
}
type SpActionMenuCustomElementProps = import('react').DetailedHTMLProps<
import('react').HTMLAttributes<HTMLElement>,
HTMLElement
> & {
quiet?: boolean
size?: 'xs' | 's' | 'm' | 'l' | 'xl'
label?: string
disabled?: boolean
open?: boolean
placement?:
| 'top'
| 'top-start'
| 'top-end'
| 'right'
| 'right-start'
| 'right-end'
| 'bottom'
| 'bottom-start'
| 'bottom-end'
| 'left'
| 'left-start'
| 'left-end'
'force-popover'?: boolean
selects?: 'single'
value?: string
slot?: string
}
type SpMenuCustomElementProps = import('react').DetailedHTMLProps<
import('react').HTMLAttributes<HTMLElement>,
HTMLElement
> & {
slot?: string
selects?: 'single' | 'multiple' | 'inherit'
label?: string
}
type SpMenuItemCustomElementProps = import('react').DetailedHTMLProps<
import('react').HTMLAttributes<HTMLElement>,
HTMLElement
> & {
disabled?: boolean
selected?: boolean
value?: string
slot?: string
}
type SpMenuDividerCustomElementProps = import('react').DetailedHTMLProps<
import('react').HTMLAttributes<HTMLElement>,
HTMLElement
> & {
size?: 's' | 'm' | 'l'
}
type SpMenuGroupCustomElementProps = import('react').DetailedHTMLProps<
import('react').HTMLAttributes<HTMLElement>,
HTMLElement
> & {
slot?: string
}
type SpStatusLightCustomElementProps = import('react').DetailedHTMLProps<
import('react').HTMLAttributes<HTMLElement>,
HTMLElement
> & {
variant?:
| 'negative'
| 'notice'
| 'positive'
| 'info'
| 'neutral'
| 'yellow'
| 'fuchsia'
| 'indigo'
| 'seafoam'
| 'chartreuse'
| 'magenta'
| 'celery'
| 'purple'
| string
disabled?: boolean
slot?: string
}
type SpProgressCircleCustomElementProps = import('react').DetailedHTMLProps<
import('react').HTMLAttributes<HTMLElement>,
HTMLElement
> & {
size?: 's' | 'm' | 'l'
indeterminate?: boolean
label?: string
slot?: string
'static-color'?: 'white' | string
}
type SpTopNavCustomElementProps = import('react').DetailedHTMLProps<
import('react').HTMLAttributes<HTMLElement>,
HTMLElement
> & {
selected?: string
quiet?: boolean
compact?: boolean
label?: string
}
type SpTopNavItemCustomElementProps = import('react').DetailedHTMLProps<
import('react').HTMLAttributes<HTMLElement>,
HTMLElement
> & {
value?: string
selected?: boolean
href?: string
disabled?: boolean
}
declare namespace React {
namespace JSX {
interface IntrinsicElements {
'sp-icon': SpIconCustomElementProps
'sp-icon-refresh': SpIconCustomElementProps
'sp-icon-chevron-down': SpIconCustomElementProps
'sp-icon-chevron-right': SpIconCustomElementProps
'sp-icon-log-out': SpIconCustomElementProps
'sp-icon-arrow-right': SpIconCustomElementProps
'sp-icon-filmstrip': SpIconCustomElementProps
'sp-icon-folder': SpIconCustomElementProps
'sp-icon-folder-open': SpIconCustomElementProps
'sp-icon-audio': SpIconCustomElementProps
'sp-icon-image': SpIconCustomElementProps
'sp-icon-document': SpIconCustomElementProps
'sp-icon-link': SpIconCustomElementProps
'sp-icon-unlink': SpIconCustomElementProps
'sp-icon-link-out': SpIconCustomElementProps
'sp-icon-download': SpIconCustomElementProps
'sp-icon-briefcase': SpIconCustomElementProps
'sp-icon-alert-circle': SpIconCustomElementProps
'sp-icon-alert-triangle': SpIconCustomElementProps
'sp-icon-checkmark-circle': SpIconCustomElementProps
'sp-icon-close': SpIconCustomElementProps
'sp-icon-movie-camera': SpIconCustomElementProps
'sp-icon-video-filled': SpIconCustomElementProps
'sp-button': SpButtonCustomElementProps
'sp-button-group': SpButtonGroupCustomElementProps
'sp-action-button': SpActionButtonCustomElementProps
'sp-action-menu': SpActionMenuCustomElementProps
'sp-menu': SpMenuCustomElementProps
'sp-menu-item': SpMenuItemCustomElementProps
'sp-menu-divider': SpMenuDividerCustomElementProps
'sp-menu-group': SpMenuGroupCustomElementProps
'sp-status-light': SpStatusLightCustomElementProps
'sp-progress-circle': SpProgressCircleCustomElementProps
'sp-top-nav': SpTopNavCustomElementProps
'sp-top-nav-item': SpTopNavItemCustomElementProps
}
}
}
declare namespace JSX {
interface IntrinsicElements {
'sp-icon': SpIconCustomElementProps
'sp-icon-refresh': SpIconCustomElementProps
'sp-icon-chevron-down': SpIconCustomElementProps
'sp-icon-chevron-right': SpIconCustomElementProps
'sp-icon-log-out': SpIconCustomElementProps
'sp-icon-arrow-right': SpIconCustomElementProps
'sp-icon-filmstrip': SpIconCustomElementProps
'sp-icon-folder': SpIconCustomElementProps
'sp-icon-folder-open': SpIconCustomElementProps
'sp-icon-audio': SpIconCustomElementProps
'sp-icon-image': SpIconCustomElementProps
'sp-icon-document': SpIconCustomElementProps
'sp-icon-link': SpIconCustomElementProps
'sp-icon-unlink': SpIconCustomElementProps
'sp-icon-link-out': SpIconCustomElementProps
'sp-icon-download': SpIconCustomElementProps
'sp-icon-briefcase': SpIconCustomElementProps
'sp-icon-alert-circle': SpIconCustomElementProps
'sp-icon-alert-triangle': SpIconCustomElementProps
'sp-icon-checkmark-circle': SpIconCustomElementProps
'sp-icon-close': SpIconCustomElementProps
'sp-icon-movie-camera': SpIconCustomElementProps
'sp-icon-video-filled': SpIconCustomElementProps
'sp-button': SpButtonCustomElementProps
'sp-button-group': SpButtonGroupCustomElementProps
'sp-action-button': SpActionButtonCustomElementProps
'sp-action-menu': SpActionMenuCustomElementProps
'sp-menu': SpMenuCustomElementProps
'sp-menu-item': SpMenuItemCustomElementProps
'sp-menu-divider': SpMenuDividerCustomElementProps
'sp-menu-group': SpMenuGroupCustomElementProps
'sp-status-light': SpStatusLightCustomElementProps
'sp-progress-circle': SpProgressCircleCustomElementProps
'sp-top-nav': SpTopNavCustomElementProps
'sp-top-nav-item': SpTopNavItemCustomElementProps
}
}
type UxpEntry = UxpFileEntry | UxpFolderEntry
interface UxpFileEntry {
readonly isFile: true
readonly isFolder: false
readonly name: string
readonly nativePath: string
write(data: ArrayBuffer | string, options?: { format?: unknown; append?: boolean }): Promise<void>
}
interface UxpFolderEntry {
readonly isFile: false
readonly isFolder: true
readonly name: string
readonly nativePath: string
createFile(name: string, options?: { overwrite?: boolean }): Promise<UxpFileEntry>
getEntries(): Promise<UxpEntry[]>
getFiles?(): Promise<UxpFileEntry[]>
}
interface UxpLocalFileSystem {
getFileForSaving(
defaultName?: string,
options?: { types?: string[] },
): Promise<UxpFileEntry | null>
getFileForOpening(options?: {
allowMultiple?: boolean
types?: string[]
}): Promise<UxpFileEntry | UxpFileEntry[] | null>
getFolder(): Promise<UxpFolderEntry | null>
getTemporaryFolder(): Promise<UxpFolderEntry>
getDataFolder(): Promise<UxpFolderEntry>
getPluginFolder(): Promise<UxpFolderEntry>
}
interface UxpStorageFormats {
readonly binary: unknown
readonly utf8: unknown
}
interface UxpModule {
storage: {
localFileSystem: UxpLocalFileSystem
formats: UxpStorageFormats
}
}
declare module 'uxp' {
const uxp: UxpModule
export = uxp
}
+52
View File
@@ -0,0 +1,52 @@
import './polyfills'
import React from 'react'
import { createRoot } from 'react-dom/client'
import { Theme } from '@swc-react/theme'
import '@spectrum-web-components/theme/theme-dark.js'
import '@spectrum-web-components/theme/theme-darkest.js'
import '@spectrum-web-components/theme/theme-light.js'
import '@spectrum-web-components/theme/scale-medium.js'
import '@swc-uxp-wrappers/button/sp-button.js'
import '@swc-uxp-wrappers/action-button/sp-action-button.js'
import '@swc-uxp-wrappers/menu/sp-menu.js'
import '@swc-uxp-wrappers/menu/sp-menu-item.js'
import '@swc-uxp-wrappers/menu/sp-menu-divider.js'
import '@swc-uxp-wrappers/menu/sp-menu-group.js'
import '@swc-uxp-wrappers/popover/sp-popover.js'
import '@spectrum-web-components/icons-workflow/icons/sp-icon-refresh.js'
import '@spectrum-web-components/icons-workflow/icons/sp-icon-chevron-down.js'
import '@spectrum-web-components/icons-workflow/icons/sp-icon-chevron-right.js'
import '@spectrum-web-components/icons-workflow/icons/sp-icon-log-out.js'
import '@spectrum-web-components/icons-workflow/icons/sp-icon-arrow-right.js'
import '@spectrum-web-components/icons-workflow/icons/sp-icon-filmstrip.js'
import '@spectrum-web-components/icons-workflow/icons/sp-icon-folder.js'
import '@spectrum-web-components/icons-workflow/icons/sp-icon-folder-open.js'
import '@spectrum-web-components/icons-workflow/icons/sp-icon-audio.js'
import '@spectrum-web-components/icons-workflow/icons/sp-icon-image.js'
import '@spectrum-web-components/icons-workflow/icons/sp-icon-document.js'
import '@spectrum-web-components/icons-workflow/icons/sp-icon-link.js'
import '@spectrum-web-components/icons-workflow/icons/sp-icon-unlink.js'
import '@spectrum-web-components/icons-workflow/icons/sp-icon-link-out.js'
import '@spectrum-web-components/icons-workflow/icons/sp-icon-download.js'
import '@spectrum-web-components/icons-workflow/icons/sp-icon-briefcase.js'
import '@spectrum-web-components/icons-workflow/icons/sp-icon-alert-circle.js'
import '@spectrum-web-components/icons-workflow/icons/sp-icon-alert-triangle.js'
import '@spectrum-web-components/icons-workflow/icons/sp-icon-checkmark-circle.js'
import '@spectrum-web-components/icons-workflow/icons/sp-icon-close.js'
import '@spectrum-web-components/icons-workflow/icons/sp-icon-movie-camera.js'
import '@spectrum-web-components/icons-workflow/icons/sp-icon-video-filled.js'
import { App } from './App'
const container = document.getElementById('root')
if (container) {
const root = createRoot(container)
root.render(
<React.StrictMode>
<Theme theme="spectrum" scale="medium" color="dark">
<App />
</Theme>
</React.StrictMode>,
)
} else {
console.error('Failed to find root container element')
}
+12
View File
@@ -0,0 +1,12 @@
// @vitest-environment happy-dom
import { describe, it, expect } from 'vitest'
import './polyfills'
describe('polyfills', () => {
it('defines window.matchMedia polyfill when missing', () => {
expect(typeof window.matchMedia).toBe('function')
const mql = window.matchMedia('(prefers-color-scheme: dark)')
expect(mql).toBeDefined()
expect(mql.matches).toBe(false)
})
})
+31
View File
@@ -0,0 +1,31 @@
// Guard against duplicate custom element registrations during UXP development and plugin reload
if (typeof window !== 'undefined' && window.customElements) {
const origDefine = window.customElements.define.bind(window.customElements)
window.customElements.define = (
name: string,
constructor: CustomElementConstructor,
options?: ElementDefinitionOptions,
) => {
if (window.customElements.get(name)) {
return
}
origDefine(name, constructor, options)
}
}
// Polyfill window.matchMedia for Adobe UXP environment
if (typeof window !== 'undefined' && typeof window.matchMedia !== 'function') {
window.matchMedia = (query: string): MediaQueryList => {
const mql: MediaQueryList = {
matches: false,
media: query,
onchange: null,
addListener: () => {},
removeListener: () => {},
addEventListener: () => {},
removeEventListener: () => {},
dispatchEvent: () => false,
}
return mql
}
}
@@ -0,0 +1,182 @@
import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
import { autoSyncService } from './autoSyncService'
import type { Project, Sequence } from '@adobe/premierepro'
import type { CommentInfo } from '@shumai/dtos'
import * as premiereService from './premiere'
import * as linkStorage from './linkStorage'
import * as markersService from './markers'
describe('autoSyncService', () => {
beforeEach(() => {
vi.useFakeTimers()
vi.restoreAllMocks()
autoSyncService.stop()
})
afterEach(() => {
autoSyncService.stop()
vi.useRealTimers()
})
it('starts and stops background interval without throwing', () => {
autoSyncService.start('https://api.shumai.test', 'test-key')
expect(autoSyncService['timer']).not.toBeNull()
autoSyncService.stop()
expect(autoSyncService['timer']).toBeNull()
})
it('syncs all linked sequences on triggerImmediateSync', async () => {
const mockSeq = { guid: 'seq-1', name: 'Seq 1' }
const mockProject = { guid: 'proj-1' }
const mockLink = {
sequenceGuid: 'seq-1',
sequenceName: 'Seq 1',
assetId: 'asset-1',
assetName: 'video.mp4',
syncedCommentIds: [],
lastSyncAt: 0,
totalCommentsSynced: 0,
}
vi.spyOn(premiereService, 'getActiveProject').mockResolvedValue(
mockProject as unknown as Project,
)
vi.spyOn(premiereService, 'getAllSequences').mockResolvedValue([mockSeq as unknown as Sequence])
vi.spyOn(linkStorage, 'getAllLinkedSequences').mockResolvedValue([mockLink])
vi.spyOn(markersService, 'fetchAssetComments').mockResolvedValue([
{ id: 'comm-1', second: 5, message: 'hello' } as unknown as CommentInfo,
])
vi.spyOn(markersService, 'syncCommentsToSequence').mockResolvedValue({
updatedLink: { ...mockLink, syncedCommentIds: ['comm-1'] },
addedCount: 1,
})
autoSyncService.start('https://api.shumai.test', 'test-key')
await autoSyncService.triggerImmediateSync()
expect(markersService.fetchAssetComments).toHaveBeenCalledWith(
'https://api.shumai.test',
'test-key',
'asset-1',
)
expect(markersService.syncCommentsToSequence).toHaveBeenCalled()
})
it('normalizes sequence GUIDs with braces and uppercase when matching against linked sequences', async () => {
const mockSeq = { guid: '{B991F605-7BD7-4028-B05F-0BC36B66CD0A}', name: 'Seq Braced' }
const mockProject = { guid: 'proj-1' }
const mockLink = {
sequenceGuid: 'b991f605-7bd7-4028-b05f-0bc36b66cd0a',
sequenceName: 'Seq Braced',
assetId: 'asset-99',
assetName: 'video.mp4',
syncedCommentIds: [],
lastSyncAt: 0,
totalCommentsSynced: 0,
}
vi.spyOn(premiereService, 'getActiveProject').mockResolvedValue(
mockProject as unknown as Project,
)
vi.spyOn(premiereService, 'getAllSequences').mockResolvedValue([mockSeq as unknown as Sequence])
vi.spyOn(linkStorage, 'getAllLinkedSequences').mockResolvedValue([mockLink])
vi.spyOn(markersService, 'fetchAssetComments').mockResolvedValue([
{ id: 'comm-1', second: 1, message: 'braced guid comment' } as unknown as CommentInfo,
])
vi.spyOn(markersService, 'syncCommentsToSequence').mockResolvedValue({
updatedLink: { ...mockLink, syncedCommentIds: ['comm-1'] },
addedCount: 1,
})
autoSyncService.start('https://api.shumai.test', 'test-key')
await autoSyncService.triggerImmediateSync()
expect(markersService.fetchAssetComments).toHaveBeenCalledWith(
'https://api.shumai.test',
'test-key',
'asset-99',
)
expect(markersService.syncCommentsToSequence).toHaveBeenCalledWith(
mockProject,
mockSeq,
expect.any(Array),
mockLink,
)
})
it('skips linked sequences configured for a different server endpoint', async () => {
const mockSeq1 = { guid: 'seq-foreign', name: 'Seq Foreign' }
const mockSeq2 = { guid: 'seq-local', name: 'Seq Local' }
const mockProject = { guid: 'proj-1' }
const foreignLink = {
sequenceGuid: 'seq-foreign',
sequenceName: 'Seq Foreign',
assetId: 'asset-foreign',
assetName: 'foreign.mp4',
endpoint: 'http://localhost:3000',
syncedCommentIds: [],
lastSyncAt: 0,
totalCommentsSynced: 0,
}
const sameLink = {
sequenceGuid: 'seq-local',
sequenceName: 'Seq Local',
assetId: 'asset-local',
assetName: 'local.mp4',
endpoint: 'https://staging.shumai.one/', // trailing slash variation
syncedCommentIds: [],
lastSyncAt: 0,
totalCommentsSynced: 0,
}
vi.spyOn(premiereService, 'getActiveProject').mockResolvedValue(
mockProject as unknown as Project,
)
vi.spyOn(premiereService, 'getAllSequences').mockResolvedValue([
mockSeq1 as unknown as Sequence,
mockSeq2 as unknown as Sequence,
])
vi.spyOn(linkStorage, 'getAllLinkedSequences').mockResolvedValue([foreignLink, sameLink])
vi.spyOn(markersService, 'fetchAssetComments').mockResolvedValue([
{ id: 'comm-1', second: 2, message: 'comment' } as unknown as CommentInfo,
])
vi.spyOn(markersService, 'syncCommentsToSequence').mockResolvedValue({
updatedLink: { ...sameLink, syncedCommentIds: ['comm-1'] },
addedCount: 1,
})
autoSyncService.start('https://staging.shumai.one', 'test-key')
await autoSyncService.triggerImmediateSync()
// Foreign link should be skipped
expect(markersService.fetchAssetComments).not.toHaveBeenCalledWith(
expect.anything(),
expect.anything(),
'asset-foreign',
)
// Matching link should be synced
expect(markersService.fetchAssetComments).toHaveBeenCalledWith(
'https://staging.shumai.one',
'test-key',
'asset-local',
)
expect(markersService.syncCommentsToSequence).toHaveBeenCalledWith(
mockProject,
mockSeq2,
expect.any(Array),
sameLink,
)
})
it('aborts syncing when stop() is called and credentials are reset', async () => {
const fetchSpy = vi.spyOn(markersService, 'fetchAssetComments')
autoSyncService.start('https://api.shumai.test', 'test-key')
autoSyncService.stop()
await autoSyncService.triggerImmediateSync()
expect(fetchSpy).not.toHaveBeenCalled()
})
})
@@ -0,0 +1,175 @@
import type { Sequence } from '@adobe/premierepro'
import { getActiveProject, getAllSequences, getPremiereModule } from './premiere'
import { getAllLinkedSequences, normalizeGuid } from './linkStorage'
import { fetchAssetComments, syncCommentsToSequence } from './markers'
import { isSameEndpoint } from '../utils/url'
const SYNC_INTERVAL_MS = 12000 // 12 seconds
class AutoSyncService {
private timer: ReturnType<typeof setInterval> | null = null
private endpoint = ''
private apiKey = ''
private cleanupListeners: (() => void) | null = null
private syncPromise: Promise<void> | null = null
/**
* Starts the background auto-sync loop.
*/
start(endpoint: string, apiKey: string): void {
this.stop()
this.endpoint = endpoint
this.apiKey = apiKey
if (!endpoint || !apiKey) return
// Setup background interval
this.timer = setInterval(() => {
void this.syncAllLinkedSequences()
}, SYNC_INTERVAL_MS)
// Setup host and window event listeners
this.setupListeners()
}
/**
* Stops the background auto-sync loop and tears down listeners.
*/
stop(): void {
if (this.timer) {
clearInterval(this.timer)
this.timer = null
}
if (this.cleanupListeners) {
this.cleanupListeners()
this.cleanupListeners = null
}
this.endpoint = ''
this.apiKey = ''
this.syncPromise = null
}
/**
* Forces an immediate synchronization cycle.
*/
async triggerImmediateSync(): Promise<void> {
if (this.syncPromise) {
await this.syncPromise
}
await this.syncAllLinkedSequences()
}
private setupListeners(): void {
const onFocus = () => {
void this.triggerImmediateSync()
}
const onVisibilityChange = () => {
if (typeof document !== 'undefined' && document.visibilityState === 'visible') {
void this.triggerImmediateSync()
}
}
if (typeof window !== 'undefined') {
window.addEventListener('focus', onFocus)
}
if (typeof document !== 'undefined') {
document.addEventListener('visibilitychange', onVisibilityChange)
}
// Premiere Pro Sequence Activated listener
const ppro = getPremiereModule()
let hasSeqListener = false
const onSequenceActivated = () => {
void this.triggerImmediateSync()
}
if (ppro?.EventManager && ppro.Constants?.SequenceEvent?.ACTIVATED) {
try {
ppro.EventManager.addGlobalEventListener(
ppro.Constants.SequenceEvent.ACTIVATED,
onSequenceActivated,
)
hasSeqListener = true
} catch (err) {
console.warn('[autoSyncService] Could not register SequenceEvent listener:', err)
}
}
this.cleanupListeners = () => {
if (typeof window !== 'undefined') {
window.removeEventListener('focus', onFocus)
}
if (typeof document !== 'undefined') {
document.removeEventListener('visibilitychange', onVisibilityChange)
}
if (hasSeqListener && ppro?.EventManager && ppro.Constants?.SequenceEvent?.ACTIVATED) {
try {
ppro.EventManager.removeGlobalEventListener(
ppro.Constants.SequenceEvent.ACTIVATED,
onSequenceActivated,
)
} catch {
// Ignore error during cleanup
}
}
}
}
private async syncAllLinkedSequences(): Promise<void> {
if (this.syncPromise) {
return this.syncPromise
}
const currentEndpoint = this.endpoint
const currentApiKey = this.apiKey
if (!currentEndpoint || !currentApiKey) return
this.syncPromise = (async () => {
try {
const project = await getActiveProject()
if (!project || this.endpoint !== currentEndpoint || this.apiKey !== currentApiKey) return
const allSeqs = await getAllSequences(project)
if (!allSeqs || allSeqs.length === 0 || this.endpoint !== currentEndpoint) return
const linkedItems = await getAllLinkedSequences(project, allSeqs)
if (!linkedItems || linkedItems.length === 0 || this.endpoint !== currentEndpoint) return
const seqsMap = new Map<string, Sequence>()
for (const s of allSeqs) {
const normGuid = normalizeGuid(s.guid)
if (normGuid) {
seqsMap.set(normGuid, s)
}
}
for (const link of linkedItems) {
if (this.endpoint !== currentEndpoint || this.apiKey !== currentApiKey) break
// Skip links created against a different server endpoint
if (link.endpoint && !isSameEndpoint(link.endpoint, currentEndpoint)) {
continue
}
const targetSeq = seqsMap.get(normalizeGuid(link.sequenceGuid))
if (!targetSeq) continue
try {
const comments = await fetchAssetComments(currentEndpoint, currentApiKey, link.assetId)
if (this.endpoint !== currentEndpoint) break
await syncCommentsToSequence(project, targetSeq, comments, link)
} catch (itemErr) {
console.error(`[autoSyncService] Error syncing sequence ${link.sequenceName}:`, itemErr)
}
}
} catch (err) {
console.error('[autoSyncService] Sync cycle failed:', err)
} finally {
this.syncPromise = null
}
})()
return this.syncPromise
}
}
export const autoSyncService = new AutoSyncService()
@@ -0,0 +1,124 @@
import { describe, it, expect, vi, beforeEach } from 'vitest'
import { fetchAssetComments, formatCommentBody } from './commentUtils'
import * as clientModule from '../api/client'
import type { CommentInfo } from '@shumai/dtos'
describe('commentUtils', () => {
beforeEach(() => {
vi.restoreAllMocks()
})
describe('fetchAssetComments', () => {
it('returns comments array when response is ok', async () => {
const mockComments: Partial<CommentInfo>[] = [
{ id: 'c1', message: 'First comment', second: 12 },
{ id: 'c2', message: 'Second comment', second: 45 },
]
const mockGet = vi.fn().mockResolvedValue({
ok: true,
json: async () => ({ data: mockComments }),
})
vi.spyOn(clientModule, 'getShumaiClient').mockReturnValue({
api: {
files: {
':fileId': {
comments: {
$get: mockGet,
},
},
},
},
// eslint-disable-next-line @typescript-eslint/no-explicit-any
} as any)
const result = await fetchAssetComments('https://api.shumai.test', 'test-key', 'asset-1')
expect(mockGet).toHaveBeenCalledWith({
param: { fileId: 'asset-1' },
query: { first: '100' },
})
expect(result).toEqual(mockComments)
})
it('throws error with message from server response when res.ok is false', async () => {
const mockGet = vi.fn().mockResolvedValue({
ok: false,
status: 404,
json: async () => ({ error: 'Asset not found on this server' }),
})
vi.spyOn(clientModule, 'getShumaiClient').mockReturnValue({
api: {
files: {
':fileId': {
comments: {
$get: mockGet,
},
},
},
},
// eslint-disable-next-line @typescript-eslint/no-explicit-any
} as any)
await expect(
fetchAssetComments('https://api.shumai.test', 'test-key', 'asset-missing'),
).rejects.toThrow('Asset not found on this server')
})
it('throws fallback HTTP status error when res.ok is false and response has no error field', async () => {
const mockGet = vi.fn().mockResolvedValue({
ok: false,
status: 500,
json: async () => {
throw new Error('Invalid JSON')
},
})
vi.spyOn(clientModule, 'getShumaiClient').mockReturnValue({
api: {
files: {
':fileId': {
comments: {
$get: mockGet,
},
},
},
},
// eslint-disable-next-line @typescript-eslint/no-explicit-any
} as any)
await expect(
fetchAssetComments('https://api.shumai.test', 'test-key', 'asset-crash'),
).rejects.toThrow('Failed to fetch comments (HTTP 500)')
})
})
describe('formatCommentBody', () => {
it('formats single comment without replies', () => {
const comment = {
message: 'Review cut at 01:23',
replies: [],
} as unknown as CommentInfo
expect(formatCommentBody(comment)).toBe('Review cut at 01:23')
})
it('formats comment with nested replies and authors', () => {
const comment = {
message: 'Needs color correction',
replies: [
{ creator: { name: 'Alice' }, message: 'Applied LUT' },
{ creator: { name: 'Bob' }, message: 'Looks better' },
],
} as unknown as CommentInfo
const result = formatCommentBody(comment)
expect(result).toContain('Needs color correction')
expect(result).toContain('--- Replies ---')
expect(result).toContain('Alice: Applied LUT')
expect(result).toContain('Bob: Looks better')
})
})
})
@@ -0,0 +1,43 @@
import type { CommentInfo } from '@shumai/dtos'
import { getShumaiClient } from '../api/client'
/**
* Fetches timecoded comments for an asset from Shumai.
*/
export async function fetchAssetComments(
endpoint: string,
apiKey: string,
assetId: string,
): Promise<CommentInfo[]> {
const client = getShumaiClient(endpoint, apiKey)
const res = await client.api.files[':fileId'].comments.$get({
param: { fileId: assetId },
query: { first: '100' },
})
if (!res.ok) {
const errData = (await res.json().catch(() => ({}))) as { error?: string }
throw new Error(errData.error || `Failed to fetch comments (HTTP ${res.status})`)
}
const data = await res.json()
return (data?.data as CommentInfo[]) || []
}
/**
* Formats a Shumai comment into marker text including any threaded replies.
*/
export function formatCommentBody(comment: CommentInfo): string {
let body = comment.message || ''
if (comment.replies && comment.replies.length > 0) {
body += '\n\n--- Replies ---'
for (const reply of comment.replies) {
const author = reply.creator?.name || 'User'
const replyMsg = reply.message || ''
body += `\n${author}: ${replyMsg}`
}
}
return body
}
@@ -0,0 +1,619 @@
import { describe, it, expect, vi, beforeEach } from 'vitest'
import {
formatResolutionLabel,
getResolutionRank,
resolveRawDownloadUrl,
fetchVideoProxies,
getUniqueFileName,
getFolderEntryNames,
createUniqueFileInFolder,
importAssetIntoPremiere,
} from './import'
import * as premiereModule from './premiere'
import * as clientModule from '../api/client'
import type { AssetSummary } from '../components/FileItem'
describe('import service', () => {
beforeEach(() => {
vi.restoreAllMocks()
})
describe('formatResolutionLabel', () => {
it('formats given resolution strings', () => {
expect(formatResolutionLabel(undefined, undefined, '1080p')).toBe('1080p (MP4)')
expect(formatResolutionLabel(undefined, undefined, '720')).toBe('720p (MP4)')
})
it('formats given height numbers', () => {
expect(formatResolutionLabel(1920, 1080)).toBe('1080p (MP4)')
expect(formatResolutionLabel(1280, 720)).toBe('720p (MP4)')
})
it('formats by width if height is missing', () => {
expect(formatResolutionLabel(1920, undefined)).toBe('1080p (MP4)')
expect(formatResolutionLabel(1280, undefined)).toBe('720p (MP4)')
expect(formatResolutionLabel(3840, undefined)).toBe('2160p (MP4)')
})
it('falls back to Proxy (MP4)', () => {
expect(formatResolutionLabel(undefined, undefined)).toBe('Proxy (MP4)')
})
})
describe('getResolutionRank', () => {
it('extracts resolution numeric rank', () => {
expect(getResolutionRank('1080p (MP4)')).toBe(1080)
expect(getResolutionRank('720p (MP4)')).toBe(720)
expect(getResolutionRank('Proxy (MP4)')).toBe(0)
})
})
describe('resolveRawDownloadUrl', () => {
it('resolves directly via download-url when original key is in knownAsset', async () => {
const mockDownloadUrlPost = vi.fn().mockResolvedValue({
ok: true,
json: async () => ({ url: 'https://s3.example.com/direct-raw.mp4' }),
})
vi.spyOn(clientModule, 'getShumaiClient').mockReturnValue({
api: {
files: {
'download-url': {
$post: mockDownloadUrlPost,
},
},
},
// eslint-disable-next-line @typescript-eslint/no-explicit-any
} as any)
const knownAsset: AssetSummary = {
id: 'file-1',
name: 'direct-raw.mp4',
type: 'file',
media: {
original: {
key: 'files/test/direct-raw.mp4',
},
},
}
const result = await resolveRawDownloadUrl('http://test', 'key', 'file-1', knownAsset)
expect(result.url).toBe('https://s3.example.com/direct-raw.mp4')
expect(result.name).toBe('direct-raw.mp4')
expect(mockDownloadUrlPost).toHaveBeenCalledWith({
json: { key: 'files/test/direct-raw.mp4', assetId: 'file-1' },
})
})
it('resolves via GET :fileId and download-url when not in knownAsset', async () => {
const mockGet = vi.fn().mockResolvedValue({
ok: true,
json: async () => ({
id: 'file-1',
name: 'remote-video.mp4',
media: {
original: {
key: 'files/remote/video.mp4',
},
},
}),
})
const mockDownloadUrlPost = vi.fn().mockResolvedValue({
ok: true,
json: async () => ({ url: 'https://s3.example.com/presigned-remote.mp4' }),
})
vi.spyOn(clientModule, 'getShumaiClient').mockReturnValue({
api: {
files: {
':fileId': {
$get: mockGet,
},
'download-url': {
$post: mockDownloadUrlPost,
},
},
},
// eslint-disable-next-line @typescript-eslint/no-explicit-any
} as any)
const result = await resolveRawDownloadUrl('http://test', 'key', 'file-1')
expect(result.url).toBe('https://s3.example.com/presigned-remote.mp4')
expect(result.name).toBe('remote-video.mp4')
expect(mockGet).toHaveBeenCalledWith({ param: { fileId: 'file-1' } })
expect(mockDownloadUrlPost).toHaveBeenCalledWith({
json: { key: 'files/remote/video.mp4', assetId: 'file-1' },
})
})
it('falls back to download-links endpoint when download-url is unavailable', async () => {
const mockPost = vi.fn().mockResolvedValue({
ok: true,
json: async () => ({
files: [{ id: 'file-1', name: 'video.mov', url: 'https://s3.example.com/video.mov' }],
}),
})
vi.spyOn(clientModule, 'getShumaiClient').mockReturnValue({
api: {
files: {
'download-links': {
$post: mockPost,
},
},
},
// Partial mock of Hono client for unit test isolation
// eslint-disable-next-line @typescript-eslint/no-explicit-any
} as any)
const result = await resolveRawDownloadUrl('http://test', 'key', 'file-1')
expect(result.url).toBe('https://s3.example.com/video.mov')
expect(result.name).toBe('video.mov')
expect(mockPost).toHaveBeenCalledWith({ json: { ids: ['file-1'] } })
})
it('throws error when all resolution methods fail', async () => {
vi.spyOn(clientModule, 'getShumaiClient').mockReturnValue({
api: {
files: {
'download-links': {
$post: vi.fn().mockResolvedValue({
ok: false,
status: 500,
json: async () => ({ error: 'Server error' }),
}),
},
},
},
// Partial mock of Hono client for unit test isolation
// eslint-disable-next-line @typescript-eslint/no-explicit-any
} as any)
await expect(resolveRawDownloadUrl('http://test', 'key', 'file-1')).rejects.toThrow(
'Server error',
)
})
})
describe('fetchVideoProxies', () => {
it('returns available proxies sorted descending', async () => {
const mockGet = vi.fn().mockResolvedValue({
ok: true,
json: async () => ({
id: 'file-1',
media: {
videoTranscodes: [
{
id: 't-720',
key: 'files/720.mp4',
url: 'https://s3.example.com/720.mp4',
width: 1280,
height: 720,
},
{
id: 't-1080',
key: 'files/1080.mp4',
url: 'https://s3.example.com/1080.mp4',
width: 1920,
height: 1080,
},
],
},
}),
})
vi.spyOn(clientModule, 'getShumaiClient').mockReturnValue({
api: {
files: {
':fileId': {
$get: mockGet,
},
},
},
// Partial mock of Hono client for unit test isolation
// eslint-disable-next-line @typescript-eslint/no-explicit-any
} as any)
const proxies = await fetchVideoProxies('http://test', 'key', 'file-1')
expect(proxies).toHaveLength(2)
// Highest resolution first
expect(proxies[0].label).toBe('1080p (MP4)')
expect(proxies[1].label).toBe('720p (MP4)')
})
})
describe('getUniqueFileName', () => {
it('returns exact name when no collision exists', () => {
expect(getUniqueFileName([], 'image.png')).toBe('image.png')
expect(getUniqueFileName(['other.png', 'test.mov'], 'image.png')).toBe('image.png')
})
it('appends _1 on first collision', () => {
expect(getUniqueFileName(['image.png'], 'image.png')).toBe('image_1.png')
})
it('appends _2 when original and _1 both exist', () => {
expect(getUniqueFileName(['image.png', 'image_1.png'], 'image.png')).toBe('image_2.png')
})
it('handles case-insensitive collision checks', () => {
expect(getUniqueFileName(['IMAGE.PNG'], 'image.png')).toBe('image_1.png')
expect(getUniqueFileName(['image.png', 'IMAGE_1.PNG'], 'image.png')).toBe('image_2.png')
})
it('handles files without extensions', () => {
expect(getUniqueFileName(['README'], 'README')).toBe('README_1')
expect(getUniqueFileName(['README', 'README_1'], 'README')).toBe('README_2')
})
it('handles files with multiple dots', () => {
expect(getUniqueFileName(['archive.tar.gz'], 'archive.tar.gz')).toBe('archive.tar_1.gz')
expect(getUniqueFileName(['archive.tar.gz', 'archive.tar_1.gz'], 'archive.tar.gz')).toBe(
'archive.tar_2.gz',
)
})
})
describe('getFolderEntryNames', () => {
it('reads entry names from folder.getEntries', async () => {
const mockFolder = {
isFile: false as const,
isFolder: true as const,
name: 'dir',
nativePath: '/path/dir',
createFile: vi.fn(),
getEntries: vi.fn().mockResolvedValue([
{ name: 'file1.mp4', isFile: true, isFolder: false },
{ name: 'subfolder', isFile: false, isFolder: true },
]),
}
const names = await getFolderEntryNames(mockFolder)
expect(names).toEqual(['file1.mp4', 'subfolder'])
})
it('handles folder.getEntries error gracefully', async () => {
const mockFolder = {
isFile: false as const,
isFolder: true as const,
name: 'dir',
nativePath: '/path/dir',
createFile: vi.fn(),
getEntries: vi.fn().mockRejectedValue(new Error('Permission denied')),
}
const names = await getFolderEntryNames(mockFolder)
expect(names).toEqual([])
})
})
describe('createUniqueFileInFolder', () => {
it('creates file with candidate name when no collision', async () => {
const mockCreatedFile = {
isFile: true as const,
isFolder: false as const,
name: 'test.mp4',
nativePath: '/path/test.mp4',
write: vi.fn(),
}
const mockFolder = {
isFile: false as const,
isFolder: true as const,
name: 'dir',
nativePath: '/path/dir',
createFile: vi.fn().mockResolvedValue(mockCreatedFile),
getEntries: vi.fn().mockResolvedValue([]),
}
const res = await createUniqueFileInFolder(mockFolder, 'test.mp4')
expect(res.name).toBe('test.mp4')
expect(res.file).toBe(mockCreatedFile)
expect(mockFolder.createFile).toHaveBeenCalledWith('test.mp4', { overwrite: false })
})
it('auto-increments suffix when candidate creation fails due to collision', async () => {
const mockCreatedFile = {
isFile: true as const,
isFolder: false as const,
name: 'test_1.mp4',
nativePath: '/path/test_1.mp4',
write: vi.fn(),
}
const mockFolder = {
isFile: false as const,
isFolder: true as const,
name: 'dir',
nativePath: '/path/dir',
createFile: vi
.fn()
.mockRejectedValueOnce(new Error('File exists'))
.mockResolvedValueOnce(mockCreatedFile),
getEntries: vi.fn().mockResolvedValue([]),
}
const res = await createUniqueFileInFolder(mockFolder, 'test.mp4')
expect(res.name).toBe('test_1.mp4')
expect(res.file).toBe(mockCreatedFile)
})
})
describe('importAssetIntoPremiere', () => {
const mockAsset: AssetSummary = {
id: 'asset-1',
name: 'Sample.mov',
type: 'file',
}
it('returns error when no active project in Premiere', async () => {
vi.spyOn(premiereModule, 'getActiveProject').mockResolvedValue(null)
const result = await importAssetIntoPremiere({
endpoint: 'http://test',
apiKey: 'key',
asset: mockAsset,
type: 'raw',
})
expect(result.success).toBe(false)
expect(result.message).toContain('Please open or create a project')
})
it('returns cancelled when user cancels folder picker', async () => {
// Mocking incomplete Premiere Project object in unit test
// eslint-disable-next-line @typescript-eslint/no-explicit-any
vi.spyOn(premiereModule, 'getActiveProject').mockResolvedValue({} as any)
vi.spyOn(premiereModule, 'promptSelectFolder').mockResolvedValue(null)
const result = await importAssetIntoPremiere({
endpoint: 'http://test',
apiKey: 'key',
asset: mockAsset,
type: 'raw',
})
expect(result.success).toBe(false)
expect(result.cancelled).toBe(true)
expect(premiereModule.promptSelectFolder).toHaveBeenCalled()
})
it('fails after folder selection if download link resolution fails', async () => {
// Mocking incomplete Premiere Project object in unit test
// eslint-disable-next-line @typescript-eslint/no-explicit-any
vi.spyOn(premiereModule, 'getActiveProject').mockResolvedValue({} as any)
const mockFolder = {
isFile: false as const,
isFolder: true as const,
name: 'dir',
nativePath: '/path/dir',
createFile: vi.fn(),
getEntries: vi.fn().mockResolvedValue([]),
}
vi.spyOn(premiereModule, 'promptSelectFolder').mockResolvedValue(mockFolder)
vi.spyOn(clientModule, 'getShumaiClient').mockReturnValue({
api: {
files: {
'download-links': {
$post: vi.fn().mockResolvedValue({
ok: false,
status: 401,
json: async () => ({ error: 'Unauthorized: Invalid API Key' }),
}),
},
},
},
// Partial mock of Hono client for unit test isolation
// eslint-disable-next-line @typescript-eslint/no-explicit-any
} as any)
await expect(
importAssetIntoPremiere({
endpoint: 'http://test',
apiKey: 'key',
asset: mockAsset,
type: 'raw',
}),
).rejects.toThrow('Unauthorized: Invalid API Key')
})
it('downloads and imports file successfully with original name when no conflict', async () => {
// Mocking incomplete Premiere Project object in unit test
// eslint-disable-next-line @typescript-eslint/no-explicit-any
const mockProject = {} as any
vi.spyOn(premiereModule, 'getActiveProject').mockResolvedValue(mockProject)
const mockSaveFile = {
isFile: true as const,
isFolder: false as const,
name: 'Sample.mov',
nativePath: '/Users/test/Downloads/Sample.mov',
write: vi.fn().mockResolvedValue(undefined),
}
const mockFolder = {
isFile: false as const,
isFolder: true as const,
name: 'Downloads',
nativePath: '/Users/test/Downloads',
createFile: vi.fn().mockResolvedValue(mockSaveFile),
getEntries: vi.fn().mockResolvedValue([]),
}
vi.spyOn(premiereModule, 'promptSelectFolder').mockResolvedValue(mockFolder)
vi.spyOn(premiereModule, 'writeBinaryFile').mockResolvedValue(undefined)
vi.spyOn(premiereModule, 'importFilesIntoProject').mockResolvedValue(true)
vi.spyOn(clientModule, 'getShumaiClient').mockReturnValue({
api: {
files: {
'download-links': {
$post: vi.fn().mockResolvedValue({
ok: true,
json: async () => ({
files: [{ id: 'asset-1', name: 'Sample.mov', url: 'https://s3.example.com/raw' }],
}),
}),
},
},
},
// Partial mock of Hono client for unit test isolation
// eslint-disable-next-line @typescript-eslint/no-explicit-any
} as any)
// Mock global fetch
const dummyBuffer = new ArrayBuffer(8)
const fetchSpy = vi.spyOn(globalThis, 'fetch').mockResolvedValue({
ok: true,
arrayBuffer: async () => dummyBuffer,
// Mocking Response object for unit test
// eslint-disable-next-line @typescript-eslint/no-explicit-any
} as any)
const onProgress = vi.fn()
const result = await importAssetIntoPremiere({
endpoint: 'http://test',
apiKey: 'key',
asset: mockAsset,
type: 'raw',
onProgress,
})
expect(result.success).toBe(true)
expect(result.fileName).toBe('Sample.mov')
expect(result.message).toContain('Successfully imported Sample.mov')
expect(mockFolder.createFile).toHaveBeenCalledWith('Sample.mov', { overwrite: false })
expect(premiereModule.importFilesIntoProject).toHaveBeenCalledWith(mockProject, [
'/Users/test/Downloads/Sample.mov',
])
expect(onProgress).toHaveBeenCalled()
fetchSpy.mockRestore()
})
it('automatically adds _1 suffix when name conflict exists in selected folder', async () => {
// Mocking incomplete Premiere Project object in unit test
// eslint-disable-next-line @typescript-eslint/no-explicit-any
const mockProject = {} as any
vi.spyOn(premiereModule, 'getActiveProject').mockResolvedValue(mockProject)
const mockSaveFile = {
isFile: true as const,
isFolder: false as const,
name: 'Sample_1.mov',
nativePath: '/Users/test/Downloads/Sample_1.mov',
write: vi.fn().mockResolvedValue(undefined),
}
const mockFolder = {
isFile: false as const,
isFolder: true as const,
name: 'Downloads',
nativePath: '/Users/test/Downloads',
createFile: vi.fn().mockResolvedValue(mockSaveFile),
getEntries: vi
.fn()
.mockResolvedValue([{ name: 'Sample.mov', isFile: true, isFolder: false }]),
}
vi.spyOn(premiereModule, 'promptSelectFolder').mockResolvedValue(mockFolder)
vi.spyOn(premiereModule, 'writeBinaryFile').mockResolvedValue(undefined)
vi.spyOn(premiereModule, 'importFilesIntoProject').mockResolvedValue(true)
vi.spyOn(clientModule, 'getShumaiClient').mockReturnValue({
api: {
files: {
'download-links': {
$post: vi.fn().mockResolvedValue({
ok: true,
json: async () => ({
files: [{ id: 'asset-1', name: 'Sample.mov', url: 'https://s3.example.com/raw' }],
}),
}),
},
},
},
// Partial mock of Hono client for unit test isolation
// eslint-disable-next-line @typescript-eslint/no-explicit-any
} as any)
const dummyBuffer = new ArrayBuffer(8)
const fetchSpy = vi.spyOn(globalThis, 'fetch').mockResolvedValue({
ok: true,
arrayBuffer: async () => dummyBuffer,
// Mocking Response object for unit test
// eslint-disable-next-line @typescript-eslint/no-explicit-any
} as any)
const result = await importAssetIntoPremiere({
endpoint: 'http://test',
apiKey: 'key',
asset: mockAsset,
type: 'raw',
})
expect(result.success).toBe(true)
expect(result.fileName).toBe('Sample_1.mov')
expect(result.message).toContain('Successfully imported Sample_1.mov')
expect(mockFolder.createFile).toHaveBeenCalledWith('Sample_1.mov', { overwrite: false })
expect(premiereModule.importFilesIntoProject).toHaveBeenCalledWith(mockProject, [
'/Users/test/Downloads/Sample_1.mov',
])
fetchSpy.mockRestore()
})
it('resolves relative download URL with endpoint before fetching', async () => {
// Mocking incomplete Premiere Project object in unit test
// eslint-disable-next-line @typescript-eslint/no-explicit-any
const mockProject = {} as any
vi.spyOn(premiereModule, 'getActiveProject').mockResolvedValue(mockProject)
const mockSaveFile = {
isFile: true as const,
isFolder: false as const,
name: 'Sample.mov',
nativePath: '/Users/test/Downloads/Sample.mov',
write: vi.fn().mockResolvedValue(undefined),
}
const mockFolder = {
isFile: false as const,
isFolder: true as const,
name: 'Downloads',
nativePath: '/Users/test/Downloads',
createFile: vi.fn().mockResolvedValue(mockSaveFile),
getEntries: vi.fn().mockResolvedValue([]),
}
vi.spyOn(premiereModule, 'promptSelectFolder').mockResolvedValue(mockFolder)
vi.spyOn(premiereModule, 'writeBinaryFile').mockResolvedValue(undefined)
vi.spyOn(premiereModule, 'importFilesIntoProject').mockResolvedValue(true)
vi.spyOn(clientModule, 'getShumaiClient').mockReturnValue({
api: {
files: {
'download-links': {
$post: vi.fn().mockResolvedValue({
ok: true,
json: async () => ({
files: [{ id: 'asset-1', name: 'Sample.mov', url: '/api/upload/local?key=test' }],
}),
}),
},
},
},
// eslint-disable-next-line @typescript-eslint/no-explicit-any
} as any)
const dummyBuffer = new ArrayBuffer(8)
const fetchSpy = vi.spyOn(globalThis, 'fetch').mockResolvedValue({
ok: true,
arrayBuffer: async () => dummyBuffer,
// eslint-disable-next-line @typescript-eslint/no-explicit-any
} as any)
const result = await importAssetIntoPremiere({
endpoint: 'http://test:3000',
apiKey: 'key',
asset: mockAsset,
type: 'raw',
})
expect(result.success).toBe(true)
expect(fetchSpy).toHaveBeenCalledWith('http://test:3000/api/upload/local?key=test')
fetchSpy.mockRestore()
})
})
})
+357
View File
@@ -0,0 +1,357 @@
import { getShumaiClient } from '../api/client'
import type { AssetSummary } from '../components/FileItem'
import {
getActiveProject,
importFilesIntoProject,
promptSelectFolder,
writeBinaryFile,
} from './premiere'
import { resolveAssetUrl } from '../utils/url'
export interface ProxyOption {
id: string
label: string
resolution: string
url: string
key: string
width?: number
height?: number
size?: number
}
export function formatResolutionLabel(width?: number, height?: number, res?: string): string {
if (res) {
const cleanRes = res.endsWith('p') ? res : `${res}p`
return `${cleanRes} (MP4)`
}
if (height) return `${height}p (MP4)`
if (width) {
if (width >= 3840) return '2160p (MP4)'
if (width >= 1920) return '1080p (MP4)'
if (width >= 1280) return '720p (MP4)'
if (width >= 960) return '540p (MP4)'
if (width >= 640) return '360p (MP4)'
}
return 'Proxy (MP4)'
}
export function getResolutionRank(label: string): number {
const match = label.match(/(\d+)p/) || label.match(/^(\d+)/)
return match ? parseInt(match[1], 10) : 0
}
/**
* Resolves the presigned download URL for the original / raw file.
*/
export async function resolveRawDownloadUrl(
endpoint: string,
apiKey: string,
assetId: string,
knownAsset?: AssetSummary,
): Promise<{ url: string; name?: string }> {
const client = getShumaiClient(endpoint, apiKey)
// 1. If original key is known directly from asset summary, presign via download-url endpoint
const directKey = knownAsset?.media?.original?.key
if (directKey) {
try {
const res = await client.api.files['download-url']?.$post({
json: { key: directKey, assetId },
})
if (res?.ok) {
const data = await res.json()
if (data.url) {
return { url: data.url, name: knownAsset?.name }
}
}
} catch (err) {
console.warn('Failed to resolve download URL via known key:', err)
}
}
// 2. Fetch full asset details via GET /api/files/:fileId to get the original media key
try {
const detailRes = await client.api.files[':fileId']?.$get({
param: { fileId: assetId },
})
if (detailRes?.ok) {
const assetData = await detailRes.json()
const originalKey = assetData.media?.original?.key
if (originalKey) {
const urlRes = await client.api.files['download-url']?.$post({
json: { key: originalKey, assetId },
})
if (urlRes?.ok) {
const urlData = await urlRes.json()
if (urlData.url) {
return { url: urlData.url, name: assetData.name || knownAsset?.name }
}
}
}
}
} catch (err) {
console.warn('Failed to fetch asset details for download URL:', err)
}
// 3. Fallback to POST /api/files/download-links batch resolution
const res = await client.api.files['download-links']?.$post({
json: { ids: [assetId] },
})
if (res?.ok) {
const data = await res.json()
const file = data.files?.[0]
if (file?.url) {
return { url: file.url, name: file.name || knownAsset?.name }
}
} else if (res) {
const errData = (await res.json().catch(() => ({}))) as { error?: string }
throw new Error(errData.error || `Failed to get download link (${res.status})`)
}
throw new Error('No download URL returned from server.')
}
/**
* Fetches available video proxy transcodes for an asset.
*/
export async function fetchVideoProxies(
endpoint: string,
apiKey: string,
assetId: string,
): Promise<ProxyOption[]> {
const client = getShumaiClient(endpoint, apiKey)
const res = await client.api.files[':fileId'].$get({
param: { fileId: assetId },
})
if (!res.ok) {
const errData = (await res.json().catch(() => ({}))) as { error?: string }
throw new Error(errData.error || `Failed to get asset details (${res.status})`)
}
const asset = await res.json()
const transcodes = asset.media?.videoTranscodes || []
if (!transcodes.length) return []
const proxies: ProxyOption[] = []
for (const t of transcodes) {
let url = t.url
if (!url && t.key) {
// If transcode url wasn't presigned yet, request via download-url endpoint
try {
const urlRes = await client.api.files['download-url'].$post({
json: { key: t.key, assetId },
})
if (urlRes.ok) {
const urlData = await urlRes.json()
url = urlData.url
}
} catch (err) {
console.warn(`Failed to presign transcode key ${t.key}:`, err)
}
}
if (url) {
const label = formatResolutionLabel(t.width, t.height)
proxies.push({
id: t.id || t.key,
label,
resolution: `${t.height || 0}p`,
url,
key: t.key,
width: t.width,
height: t.height,
size: t.size,
})
}
}
// Sort descending by resolution (1080p, 720p, 540p, 360p)
proxies.sort((a, b) => getResolutionRank(b.label) - getResolutionRank(a.label))
return proxies
}
/**
* Resolves a unique filename within the specified existing file names in a folder.
* If requestedName exists, it appends _1, _2, etc. before the file extension.
* Comparison is case-insensitive to safely handle Windows and macOS filesystems.
*/
export function getUniqueFileName(existingNames: string[], requestedName: string): string {
const existingSet = new Set(existingNames.map((n) => n.toLowerCase()))
if (!existingSet.has(requestedName.toLowerCase())) {
return requestedName
}
const dotIndex = requestedName.lastIndexOf('.')
const base = dotIndex > 0 ? requestedName.slice(0, dotIndex) : requestedName
const ext = dotIndex > 0 ? requestedName.slice(dotIndex) : ''
let counter = 1
while (true) {
const candidate = `${base}_${counter}${ext}`
if (!existingSet.has(candidate.toLowerCase())) {
return candidate
}
counter++
}
}
/**
* Reads existing file/folder names inside a UXP FolderEntry safely.
*/
export async function getFolderEntryNames(folder: UxpFolderEntry): Promise<string[]> {
try {
if (typeof folder.getEntries === 'function') {
const entries = await folder.getEntries()
return entries.map((e) => e.name)
}
const folderRecord = folder as unknown as Record<string, unknown>
if (typeof folderRecord.getFiles === 'function') {
const files = await (folderRecord.getFiles as () => Promise<Array<{ name: string }>>)()
return files.map((f) => f.name)
}
} catch (err) {
console.warn('Failed to read folder entries:', err)
}
return []
}
/**
* Creates a unique file entry in the target folder, preventing overwrites by auto-incrementing suffixes (_1, _2).
*/
export async function createUniqueFileInFolder(
folder: UxpFolderEntry,
requestedName: string,
): Promise<{ file: UxpFileEntry; name: string }> {
const existingNames = await getFolderEntryNames(folder)
const candidateName = getUniqueFileName(existingNames, requestedName)
try {
const file = await folder.createFile(candidateName, { overwrite: false })
return { file, name: candidateName }
} catch (err) {
console.warn(`Could not create file "${candidateName}" with overwrite: false, retrying...`, err)
const dotIndex = requestedName.lastIndexOf('.')
const base = dotIndex > 0 ? requestedName.slice(0, dotIndex) : requestedName
const ext = dotIndex > 0 ? requestedName.slice(dotIndex) : ''
for (let counter = 1; counter <= 50; counter++) {
const retryName = `${base}_${counter}${ext}`
try {
const file = await folder.createFile(retryName, { overwrite: false })
return { file, name: retryName }
} catch {
continue
}
}
const fallbackFile = await folder.createFile(candidateName, { overwrite: true })
return { file: fallbackFile, name: candidateName }
}
}
export interface ImportAssetOptions {
endpoint: string
apiKey: string
asset: AssetSummary
type: 'raw' | 'proxy'
proxyItem?: ProxyOption
onProgress?: (message: string) => void
}
export interface ImportResult {
success: boolean
cancelled?: boolean
message: string
fileName?: string
}
/**
* Orchestrates the full import workflow:
* 1. Checks active Premiere Pro project
* 2. Prompts user with native folder picker (Frame.io pattern)
* 3. Resolves download URL from Shumai S3 presigned URL
* 4. Resolves unique filename in folder with auto-increment (_1, _2) on collision
* 5. Downloads binary data and writes to disk
* 6. Calls Premiere project.importFiles
*/
export async function importAssetIntoPremiere({
endpoint,
apiKey,
asset,
type,
proxyItem,
onProgress,
}: ImportAssetOptions): Promise<ImportResult> {
// 1. Verify active Premiere project
const project = await getActiveProject()
if (!project) {
return {
success: false,
message: 'Please open or create a project in Premiere Pro first.',
}
}
// 2. Open native folder picker (Frame.io pattern)
const targetFolder = await promptSelectFolder()
if (!targetFolder) {
return {
success: false,
cancelled: true,
message: 'Import cancelled by user.',
}
}
// 3. Determine default filename & download URL
onProgress?.('Preparing download link...')
let downloadUrl: string
let defaultFileName: string
if (type === 'raw') {
const rawInfo = await resolveRawDownloadUrl(endpoint, apiKey, asset.id, asset)
downloadUrl = rawInfo.url
defaultFileName = rawInfo.name || asset.name
} else {
if (!proxyItem?.url) {
throw new Error('Proxy URL not available.')
}
downloadUrl = proxyItem.url
const rawName = asset.name
const dotIndex = rawName.lastIndexOf('.')
const baseName = dotIndex !== -1 ? rawName.slice(0, dotIndex) : rawName
const resTag = proxyItem ? proxyItem.label.split(' ')[0] : 'proxy'
defaultFileName = `${baseName}_proxy_${resTag}.mp4`
}
const resolvedDownloadUrl = resolveAssetUrl(downloadUrl, endpoint) || downloadUrl
// 4. Create unique file in destination folder with collision avoidance (_1, _2)
const { file: saveFile, name: finalFileName } = await createUniqueFileInFolder(
targetFolder,
defaultFileName,
)
// 5. Download binary data
onProgress?.(`Downloading ${finalFileName}...`)
const response = await fetch(resolvedDownloadUrl)
if (!response.ok) {
throw new Error(`Failed to download file (HTTP ${response.status})`)
}
const arrayBuffer = await response.arrayBuffer()
// 6. Write file to disk
onProgress?.(`Saving ${finalFileName} to disk...`)
await writeBinaryFile(saveFile, arrayBuffer)
// 7. Import into Premiere Pro
onProgress?.('Importing into Premiere Pro...')
const imported = await importFilesIntoProject(project, [saveFile.nativePath])
if (!imported) {
throw new Error(`Premiere Pro could not import "${finalFileName}".`)
}
return {
success: true,
fileName: finalFileName,
message: `Successfully imported ${finalFileName} into Premiere Pro.`,
}
}
@@ -0,0 +1,548 @@
import { describe, it, expect, vi, beforeEach } from 'vitest'
import {
saveSequenceLinkToCache,
getSequenceLinkFromCache,
removeSequenceLinkFromCache,
getAllSequenceLinksFromCache,
getAllLinkedSequences,
getSequenceLink,
saveSequenceLink,
removeSequenceLink,
normalizeGuid,
LINK_STORAGE_PROP_KEY,
} from './linkStorage'
import * as commentUtils from './commentUtils'
import type { Project, Sequence } from '@adobe/premierepro'
import type { LinkedSequenceAsset } from '../types/link'
const localStorageMock = (() => {
let store: Record<string, string> = {}
return {
getItem: (key: string) => store[key] || null,
setItem: (key: string, value: string) => {
store[key] = value.toString()
},
removeItem: (key: string) => {
delete store[key]
},
clear: () => {
store = {}
},
key: (index: number) => Object.keys(store)[index] || null,
get length() {
return Object.keys(store).length
},
}
})()
Object.defineProperty(globalThis, 'localStorage', {
value: localStorageMock,
configurable: true,
writable: true,
})
describe('linkStorage service', () => {
beforeEach(() => {
localStorage.clear()
vi.restoreAllMocks()
// Reset global require
// eslint-disable-next-line @typescript-eslint/no-explicit-any
delete (globalThis as any).require
// eslint-disable-next-line @typescript-eslint/no-explicit-any
delete (globalThis as any).window
})
const sampleLink: LinkedSequenceAsset = {
sequenceGuid: 'seq-guid-1',
sequenceName: 'Sequence 01',
assetId: 'asset-1',
assetName: 'video.mp4',
syncedCommentIds: ['comm-1', 'comm-2'],
lastSyncAt: 1000,
totalCommentsSynced: 2,
}
describe('cache operations (localStorage)', () => {
it('saves and retrieves link from cache', () => {
saveSequenceLinkToCache(sampleLink, 'proj-1')
const result = getSequenceLinkFromCache('seq-guid-1', 'proj-1')
expect(result).toEqual(sampleLink)
})
it('saves and retrieves link with endpoint from cache', () => {
const linkWithEndpoint: LinkedSequenceAsset = {
...sampleLink,
endpoint: 'https://staging.shumai.one',
}
saveSequenceLinkToCache(linkWithEndpoint, 'proj-1')
const result = getSequenceLinkFromCache('seq-guid-1', 'proj-1')
expect(result?.endpoint).toBe('https://staging.shumai.one')
})
it('returns null when link is not in cache', () => {
expect(getSequenceLinkFromCache('unknown-seq', 'proj-1')).toBeNull()
})
it('lists all links for a project', () => {
saveSequenceLinkToCache(sampleLink, 'proj-1')
const link2: LinkedSequenceAsset = {
...sampleLink,
sequenceGuid: 'seq-guid-2',
sequenceName: 'Sequence 02',
}
saveSequenceLinkToCache(link2, 'proj-1')
const all = getAllSequenceLinksFromCache('proj-1')
expect(all).toHaveLength(2)
expect(all.map((l) => l.sequenceGuid)).toContain('seq-guid-1')
expect(all.map((l) => l.sequenceGuid)).toContain('seq-guid-2')
})
it('removes a link from cache', () => {
saveSequenceLinkToCache(sampleLink, 'proj-1')
expect(getSequenceLinkFromCache('seq-guid-1', 'proj-1')).not.toBeNull()
removeSequenceLinkFromCache('seq-guid-1', 'proj-1')
expect(getSequenceLinkFromCache('seq-guid-1', 'proj-1')).toBeNull()
})
it('returns all links across projects when projectGuid is omitted', () => {
saveSequenceLinkToCache(sampleLink, 'proj-1')
const link2: LinkedSequenceAsset = {
...sampleLink,
sequenceGuid: 'seq-guid-2',
sequenceName: 'Sequence 02',
assetId: 'asset-2',
}
saveSequenceLinkToCache(link2, 'proj-2')
const all = getAllSequenceLinksFromCache()
expect(all).toHaveLength(2)
expect(all.map((l) => l.sequenceGuid)).toContain('seq-guid-1')
expect(all.map((l) => l.sequenceGuid)).toContain('seq-guid-2')
})
it('does not return links from default cache when projectGuid is specified', () => {
saveSequenceLinkToCache(sampleLink, null)
const result = getAllSequenceLinksFromCache('proj-unknown')
expect(result).toEqual([])
})
})
describe('host sequence properties integration', () => {
it('retrieves persistent property from sequence when available', async () => {
const mockProps = {
getValue: vi.fn().mockReturnValue(JSON.stringify(sampleLink)),
}
const mockPpro = {
Properties: {
getProperties: vi.fn().mockResolvedValue(mockProps),
},
}
// eslint-disable-next-line @typescript-eslint/no-explicit-any
;(globalThis as any).window = {
require: vi.fn().mockImplementation((name: string) => {
if (name === 'premierepro') return mockPpro
return null
}),
}
const mockSeq = { guid: 'seq-guid-1' }
const mockProj = { guid: 'proj-1' }
const link = await getSequenceLink(
mockSeq as unknown as Sequence,
mockProj as unknown as Project,
)
expect(link).toEqual(sampleLink)
expect(mockProps.getValue).toHaveBeenCalledWith(LINK_STORAGE_PROP_KEY)
})
it('saves persistent property and executes transaction', async () => {
const mockCompoundAction = { addAction: vi.fn() }
const mockProps = {
createSetValueAction: vi.fn().mockReturnValue({ id: 'action-set' }),
}
const mockPpro = {
Properties: {
getProperties: vi.fn().mockResolvedValue(mockProps),
PROPERTY_PERSISTENT: 1,
},
Constants: {
PropertyType: { PERSISTENT: 1 },
},
}
// eslint-disable-next-line @typescript-eslint/no-explicit-any
;(globalThis as any).window = {
require: vi.fn().mockImplementation((name: string) => {
if (name === 'premierepro') return mockPpro
return null
}),
}
const mockSeq = { guid: 'seq-guid-1' }
const mockProj = {
guid: 'proj-1',
lockedAccess: vi.fn((cb) => cb()),
executeTransaction: vi.fn((cb) => {
cb(mockCompoundAction)
return true
}),
}
const success = await saveSequenceLink(
mockProj as unknown as Project,
mockSeq as unknown as Sequence,
sampleLink,
)
expect(success).toBe(true)
expect(mockProps.createSetValueAction).toHaveBeenCalledWith(
LINK_STORAGE_PROP_KEY,
JSON.stringify(sampleLink),
1,
)
expect(mockCompoundAction.addAction).toHaveBeenCalledWith({ id: 'action-set' })
})
it('clears persistent property on removeSequenceLink', async () => {
const mockCompoundAction = { addAction: vi.fn() }
const mockProps = {
createClearValueAction: vi.fn().mockReturnValue({ id: 'action-clear' }),
}
const mockPpro = {
Properties: {
getProperties: vi.fn().mockResolvedValue(mockProps),
},
}
// eslint-disable-next-line @typescript-eslint/no-explicit-any
;(globalThis as any).window = {
require: vi.fn().mockImplementation((name: string) => {
if (name === 'premierepro') return mockPpro
return null
}),
}
const mockSeq = { guid: 'seq-guid-1' }
const mockProj = {
guid: 'proj-1',
lockedAccess: vi.fn((cb) => cb()),
executeTransaction: vi.fn((cb) => {
cb(mockCompoundAction)
return true
}),
}
const success = await removeSequenceLink(
mockProj as unknown as Project,
mockSeq as unknown as Sequence,
)
expect(success).toBe(true)
expect(mockProps.createClearValueAction).toHaveBeenCalledWith(LINK_STORAGE_PROP_KEY)
})
it('removes synced markers matching syncedMarkerGuids on removeSequenceLink, preserving manual markers', async () => {
const mockCompoundAction = { addAction: vi.fn() }
const mockProps = {
getValue: vi.fn().mockReturnValue(
JSON.stringify({
...sampleLink,
syncedMarkerGuids: ['synced-marker-1', 'synced-marker-2'],
}),
),
createClearValueAction: vi.fn().mockReturnValue({ id: 'action-clear' }),
}
const mockMarker1 = {
guid: 'synced-marker-1',
name: 'Director (edited)',
comments: 'Edited comment',
}
const mockMarker2 = { guid: 'synced-marker-2', name: 'Producer', comments: 'Another comment' }
const mockManualMarker = {
guid: 'manual-user-marker',
name: 'Editor Note',
comments: 'Manual marker',
}
const mockSeqMarkers = {
getMarkers: vi.fn().mockReturnValue([mockMarker1, mockManualMarker, mockMarker2]),
createRemoveMarkerAction: vi.fn().mockImplementation((marker) => ({
type: 'remove-marker',
guid: marker.guid,
})),
}
const mockPpro = {
Properties: {
getProperties: vi.fn().mockResolvedValue(mockProps),
},
Markers: {
getMarkers: vi.fn().mockResolvedValue(mockSeqMarkers),
},
}
// eslint-disable-next-line @typescript-eslint/no-explicit-any
;(globalThis as any).window = {
require: vi.fn().mockImplementation((name: string) => {
if (name === 'premierepro') return mockPpro
return null
}),
}
const mockSeq = { guid: 'seq-guid-1' }
const mockProj = {
guid: 'proj-1',
lockedAccess: vi.fn((cb) => cb()),
executeTransaction: vi.fn((cb) => {
cb(mockCompoundAction)
return true
}),
}
const success = await removeSequenceLink(
mockProj as unknown as Project,
mockSeq as unknown as Sequence,
)
expect(success).toBe(true)
// Only synced-marker-1 and synced-marker-2 should be removed; manual-user-marker must NOT be removed
expect(mockSeqMarkers.createRemoveMarkerAction).toHaveBeenCalledTimes(2)
expect(mockSeqMarkers.createRemoveMarkerAction).toHaveBeenCalledWith(mockMarker1)
expect(mockSeqMarkers.createRemoveMarkerAction).toHaveBeenCalledWith(mockMarker2)
expect(mockSeqMarkers.createRemoveMarkerAction).not.toHaveBeenCalledWith(mockManualMarker)
expect(mockCompoundAction.addAction).toHaveBeenCalledWith({
type: 'remove-marker',
guid: 'synced-marker-1',
})
expect(mockCompoundAction.addAction).toHaveBeenCalledWith({
type: 'remove-marker',
guid: 'synced-marker-2',
})
expect(mockProps.createClearValueAction).toHaveBeenCalledWith(LINK_STORAGE_PROP_KEY)
})
it('removes markers by comment matching fallback when syncedMarkerGuids is empty', async () => {
localStorage.setItem('shumai_uxp_endpoint', 'https://shumai.example.com')
localStorage.setItem('shumai_uxp_api_key', 'test-api-key')
vi.spyOn(commentUtils, 'fetchAssetComments').mockResolvedValue([
{
id: 'comm-1',
creator: {
id: 'u1',
name: 'Director',
} as unknown as import('@shumai/dtos').CommentInfo['creator'],
message: 'Please trim this scene',
} as unknown as import('@shumai/dtos').CommentInfo,
])
const mockCompoundAction = { addAction: vi.fn() }
const mockProps = {
getValue: vi.fn().mockReturnValue(
JSON.stringify({
...sampleLink,
syncedMarkerGuids: [],
}),
),
createClearValueAction: vi.fn().mockReturnValue({ id: 'action-clear' }),
}
const mockLegacyShumaiMarker = {
guid: 'legacy-guid-1',
getName: () => 'Director',
getComments: () => 'Please trim this scene',
}
const mockManualMarker = {
guid: 'manual-guid-2',
getName: () => 'Editor',
getComments: () => 'My own note',
}
const mockSeqMarkers = {
getMarkers: vi.fn().mockReturnValue([mockLegacyShumaiMarker, mockManualMarker]),
createRemoveMarkerAction: vi.fn().mockImplementation((marker) => ({
type: 'remove-marker',
guid: marker.guid,
})),
}
const mockPpro = {
Properties: {
getProperties: vi.fn().mockResolvedValue(mockProps),
},
Markers: {
getMarkers: vi.fn().mockResolvedValue(mockSeqMarkers),
},
}
// eslint-disable-next-line @typescript-eslint/no-explicit-any
;(globalThis as any).window = {
require: vi.fn().mockImplementation((name: string) => {
if (name === 'premierepro') return mockPpro
return null
}),
}
const mockSeq = { guid: 'seq-guid-1' }
const mockProj = {
guid: 'proj-1',
lockedAccess: vi.fn((cb) => cb()),
executeTransaction: vi.fn((cb) => {
cb(mockCompoundAction)
return true
}),
}
const success = await removeSequenceLink(
mockProj as unknown as Project,
mockSeq as unknown as Sequence,
)
expect(success).toBe(true)
expect(mockSeqMarkers.createRemoveMarkerAction).toHaveBeenCalledWith(mockLegacyShumaiMarker)
expect(mockSeqMarkers.createRemoveMarkerAction).not.toHaveBeenCalledWith(mockManualMarker)
})
it('attempts individual marker removals if compound batch remove returns false', async () => {
const mockCompoundAction = { addAction: vi.fn() }
const mockProps = {
getValue: vi.fn().mockReturnValue(
JSON.stringify({
...sampleLink,
syncedMarkerGuids: ['synced-1'],
}),
),
createClearValueAction: vi.fn().mockReturnValue({ id: 'action-clear' }),
}
const mockMarker = { guid: 'synced-1' }
const mockSeqMarkers = {
getMarkers: vi.fn().mockReturnValue([mockMarker]),
createRemoveMarkerAction: vi.fn().mockReturnValue({ type: 'remove-marker' }),
}
const mockPpro = {
Properties: {
getProperties: vi.fn().mockResolvedValue(mockProps),
},
Markers: {
getMarkers: vi.fn().mockResolvedValue(mockSeqMarkers),
},
}
// eslint-disable-next-line @typescript-eslint/no-explicit-any
;(globalThis as any).window = {
require: vi.fn().mockImplementation((name: string) => {
if (name === 'premierepro') return mockPpro
return null
}),
}
let txCount = 0
const mockProj = {
guid: 'proj-1',
lockedAccess: vi.fn((cb) => cb()),
executeTransaction: vi.fn((cb) => {
txCount++
cb(mockCompoundAction)
if (txCount === 1) return false // batch failed
return true // individual succeeded
}),
}
const mockSeq = { guid: 'seq-guid-1' }
const success = await removeSequenceLink(
mockProj as unknown as Project,
mockSeq as unknown as Sequence,
)
expect(success).toBe(true)
expect(txCount).toBeGreaterThanOrEqual(2)
})
it('skips fallback comment fetch if link endpoint does not match current session endpoint', async () => {
localStorage.setItem('shumai_uxp_endpoint', 'https://staging.shumai.one')
localStorage.setItem('shumai_uxp_api_key', 'test-key')
const fetchCommentsSpy = vi.spyOn(commentUtils, 'fetchAssetComments')
const mockSeq = {
guid: 'seq-diff-endpoint',
name: 'Diff Endpoint Seq',
}
const mockProj = {
guid: 'proj-diff',
lockedAccess: (fn: () => void) => fn(),
executeTransaction: () => true,
}
const linkFromLocal: LinkedSequenceAsset = {
...sampleLink,
sequenceGuid: 'seq-diff-endpoint',
endpoint: 'http://localhost:3000',
syncedMarkerGuids: [], // Trigger fallback
}
saveSequenceLinkToCache(linkFromLocal, 'proj-diff')
await removeSequenceLink(mockProj as unknown as Project, mockSeq as unknown as Sequence)
expect(fetchCommentsSpy).not.toHaveBeenCalled()
})
})
describe('getAllLinkedSequences', () => {
it('does not leak cached links across projects when a project has an empty sequence list', async () => {
saveSequenceLinkToCache(sampleLink, 'proj-A')
const defaultLink: LinkedSequenceAsset = {
...sampleLink,
sequenceGuid: 'seq-default',
sequenceName: 'Default Seq',
}
saveSequenceLinkToCache(defaultLink, null)
const mockProjB = {
guid: 'proj-B',
getSequences: vi.fn().mockResolvedValue([]),
}
const results = await getAllLinkedSequences(mockProjB as unknown as Project, [])
expect(results).toEqual([])
})
it('restores cached link only if the sequence actually exists in the project', async () => {
saveSequenceLinkToCache(sampleLink, 'proj-A')
const mockSeq1 = { guid: 'seq-guid-1' }
const mockSeq2 = { guid: 'seq-guid-2' }
const mockProjA = {
guid: 'proj-A',
getSequences: vi.fn().mockResolvedValue([mockSeq1]),
}
const results = await getAllLinkedSequences(mockProjA as unknown as Project, [
mockSeq1 as unknown as Sequence,
])
expect(results).toHaveLength(1)
expect(results[0].sequenceGuid).toBe('seq-guid-1')
const resultsSeq2 = await getAllLinkedSequences(mockProjA as unknown as Project, [
mockSeq2 as unknown as Sequence,
])
expect(resultsSeq2).toHaveLength(0)
})
})
describe('normalizeGuid', () => {
it('normalizes GUIDs with uppercase, braces, whitespace, and objects', () => {
expect(normalizeGuid('{1234-ABCD-5678}')).toBe('1234-abcd-5678')
expect(normalizeGuid(' ABC-DEF ')).toBe('abc-def')
expect(normalizeGuid({ toString: () => '{Guid-Obj}' })).toBe('guid-obj')
expect(normalizeGuid(null)).toBe('')
expect(normalizeGuid(undefined)).toBe('')
})
})
})
@@ -0,0 +1,472 @@
import type { Marker, Project, Sequence } from '@adobe/premierepro'
import { getPremiereModule } from './premiere'
import type { LinkedSequenceAsset } from '../types/link'
import { getStoredCredentials } from './storage'
import { fetchAssetComments, formatCommentBody } from './commentUtils'
import { isSameEndpoint } from '../utils/url'
export const LINK_STORAGE_PROP_KEY = 'shumai_linked_asset'
const STORAGE_PREFIX = '@shumai/premiere-uxp:project-links'
/**
* Normalizes a GUID or string identifier by removing curly braces,
* trimming whitespace, and converting to lower case for reliable comparison.
*/
export function normalizeGuid(guid: unknown): string {
if (!guid) return ''
const str =
typeof guid === 'string'
? guid
: typeof (guid as { toString?: () => string }).toString === 'function'
? (guid as { toString: () => string }).toString()
: String(guid)
return str.trim().toLowerCase().replace(/[{}]/g, '')
}
function getStorageKey(projectGuid?: string | null): string {
return `${STORAGE_PREFIX}:${projectGuid ? normalizeGuid(projectGuid) : 'default'}`
}
/**
* Reads all cached sequence links for a project from localStorage.
* If projectGuid is omitted or null, aggregates across all project keys in localStorage.
*/
export function getAllSequenceLinksFromCache(projectGuid?: string | null): LinkedSequenceAsset[] {
if (typeof localStorage === 'undefined') return []
try {
const normProj = projectGuid ? normalizeGuid(projectGuid) : null
if (normProj) {
const raw = localStorage.getItem(getStorageKey(normProj))
if (raw) {
const parsed = JSON.parse(raw)
if (Array.isArray(parsed)) return parsed
if (typeof parsed === 'object' && parsed !== null) {
return Object.values(parsed)
}
}
return []
}
// When projectGuid is not provided, aggregate all cached sequence links
const results: LinkedSequenceAsset[] = []
const seenGuids = new Set<string>()
// Check default key
const defaultRaw = localStorage.getItem(getStorageKey(null))
if (defaultRaw) {
try {
const parsed = JSON.parse(defaultRaw)
const items: LinkedSequenceAsset[] = Array.isArray(parsed)
? parsed
: typeof parsed === 'object' && parsed !== null
? Object.values(parsed)
: []
for (const item of items) {
const normSeq = normalizeGuid(item.sequenceGuid)
if (normSeq && !seenGuids.has(normSeq)) {
seenGuids.add(normSeq)
results.push(item)
}
}
} catch {
// Ignore JSON error
}
}
// Scan all keys matching STORAGE_PREFIX in localStorage
if (typeof localStorage.length === 'number') {
for (let i = 0; i < localStorage.length; i++) {
const key = typeof localStorage.key === 'function' ? localStorage.key(i) : null
if (key && key.startsWith(STORAGE_PREFIX)) {
const raw = localStorage.getItem(key)
if (raw) {
try {
const parsed = JSON.parse(raw)
const items: LinkedSequenceAsset[] = Array.isArray(parsed)
? parsed
: typeof parsed === 'object' && parsed !== null
? Object.values(parsed)
: []
for (const item of items) {
const normSeq = normalizeGuid(item.sequenceGuid)
if (normSeq && !seenGuids.has(normSeq)) {
seenGuids.add(normSeq)
results.push(item)
}
}
} catch {
// Ignore corrupted item
}
}
}
}
}
return results
} catch (err) {
console.warn('[linkStorage] Failed to read cached links from localStorage:', err)
return []
}
}
/**
* Gets a cached sequence link by sequence GUID from localStorage.
*/
export function getSequenceLinkFromCache(
sequenceGuid: string,
projectGuid?: string | null,
): LinkedSequenceAsset | null {
const normSeq = normalizeGuid(sequenceGuid)
const all = getAllSequenceLinksFromCache(projectGuid)
return all.find((item) => normalizeGuid(item.sequenceGuid) === normSeq) || null
}
/**
* Saves a sequence link in the local cache.
*/
export function saveSequenceLinkToCache(
linkData: LinkedSequenceAsset,
projectGuid?: string | null,
): void {
if (typeof localStorage === 'undefined') return
try {
const normSeq = normalizeGuid(linkData.sequenceGuid)
const normalizedData: LinkedSequenceAsset = {
...linkData,
sequenceGuid: normSeq,
...(linkData.syncedMarkerGuids != null
? { syncedMarkerGuids: linkData.syncedMarkerGuids.map(normalizeGuid).filter(Boolean) }
: {}),
}
if (projectGuid) {
const all = getAllSequenceLinksFromCache(projectGuid).filter(
(item) => normalizeGuid(item.sequenceGuid) !== normSeq,
)
all.push(normalizedData)
localStorage.setItem(getStorageKey(projectGuid), JSON.stringify(all))
}
// Always also update default key so it's accessible when projectGuid is unknown
const defaultAll = getAllSequenceLinksFromCache(null).filter(
(item) => normalizeGuid(item.sequenceGuid) !== normSeq,
)
defaultAll.push(normalizedData)
localStorage.setItem(getStorageKey(null), JSON.stringify(defaultAll))
} catch (err) {
console.warn('[linkStorage] Failed to save link to localStorage:', err)
}
}
/**
* Removes a sequence link from the local cache.
*/
export function removeSequenceLinkFromCache(
sequenceGuid: string,
projectGuid?: string | null,
): void {
if (typeof localStorage === 'undefined') return
try {
const normSeq = normalizeGuid(sequenceGuid)
if (projectGuid) {
const all = getAllSequenceLinksFromCache(projectGuid).filter(
(item) => normalizeGuid(item.sequenceGuid) !== normSeq,
)
localStorage.setItem(getStorageKey(projectGuid), JSON.stringify(all))
}
const defaultAll = getAllSequenceLinksFromCache(null).filter(
(item) => normalizeGuid(item.sequenceGuid) !== normSeq,
)
localStorage.setItem(getStorageKey(null), JSON.stringify(defaultAll))
// Also remove from any other keys matching STORAGE_PREFIX
if (typeof localStorage.length === 'number') {
for (let i = 0; i < localStorage.length; i++) {
const key = typeof localStorage.key === 'function' ? localStorage.key(i) : null
if (key && key.startsWith(STORAGE_PREFIX)) {
const raw = localStorage.getItem(key)
if (raw) {
try {
const parsed = JSON.parse(raw)
if (Array.isArray(parsed)) {
const filtered = parsed.filter(
(item) => normalizeGuid(item.sequenceGuid) !== normSeq,
)
localStorage.setItem(key, JSON.stringify(filtered))
}
} catch {
// Ignore
}
}
}
}
}
} catch (err) {
console.warn('[linkStorage] Failed to remove link from localStorage:', err)
}
}
/**
* Retrieves the persistent link metadata from a sequence's properties.
*/
export async function getSequenceLink(
sequence: Sequence,
project?: Project | null,
): Promise<LinkedSequenceAsset | null> {
const ppro = getPremiereModule()
const seqGuidStr = normalizeGuid(sequence.guid)
const prGuidStr = project?.guid ? normalizeGuid(project.guid) : null
// Check persistent sequence properties in Premiere
if (ppro?.Properties) {
try {
const properties = await ppro.Properties.getProperties(sequence)
const raw = properties.getValue(LINK_STORAGE_PROP_KEY)
if (raw) {
const parsed = JSON.parse(raw) as LinkedSequenceAsset
// Synchronize with cache
saveSequenceLinkToCache(parsed, prGuidStr)
return parsed
}
} catch (err) {
// Property might not exist or failed to load
console.debug('[linkStorage] No persistent property found or failed:', err)
}
}
// Fallback to local cache if sequence property was not available
return getSequenceLinkFromCache(seqGuidStr, prGuidStr)
}
/**
* Retrieves all linked sequence assets across a project.
*/
export async function getAllLinkedSequences(
project: Project,
allSequences?: Sequence[],
): Promise<LinkedSequenceAsset[]> {
const prGuidStr = project.guid ? normalizeGuid(project.guid) : null
const seqs = allSequences || (await project.getSequences()) || []
const results: LinkedSequenceAsset[] = []
const checkedGuids = new Set<string>()
for (const seq of seqs) {
const seqGuid = normalizeGuid(seq.guid)
if (seqGuid) checkedGuids.add(seqGuid)
const link = await getSequenceLink(seq, project)
if (link) {
results.push(link)
}
}
// Also check cache for any items matching known sequences
const cached = getAllSequenceLinksFromCache(prGuidStr)
for (const item of cached) {
const normItemSeq = normalizeGuid(item.sequenceGuid)
if (!results.some((r) => normalizeGuid(r.sequenceGuid) === normItemSeq)) {
if (checkedGuids.has(normItemSeq)) {
results.push(item)
}
}
}
return results
}
/**
* Saves the link metadata persistently on the sequence and in the cache.
*/
export async function saveSequenceLink(
project: Project,
sequence: Sequence,
linkData: LinkedSequenceAsset,
): Promise<boolean> {
const ppro = getPremiereModule()
const prGuidStr = project.guid ? normalizeGuid(project.guid) : null
// Always update cache first
saveSequenceLinkToCache(linkData, prGuidStr)
if (!ppro?.Properties) {
return true
}
try {
const properties = await ppro.Properties.getProperties(sequence)
const persistentType =
ppro.Constants?.PropertyType?.PERSISTENT ?? ppro.Properties.PROPERTY_PERSISTENT ?? 0
let success = false
project.lockedAccess(() => {
success = project.executeTransaction((compoundAction) => {
const setValAction = properties.createSetValueAction(
LINK_STORAGE_PROP_KEY,
JSON.stringify(linkData),
persistentType,
)
compoundAction.addAction(setValAction)
}, 'Save Shumai Link')
})
return success
} catch (err) {
console.warn('[linkStorage] Failed to set sequence persistent property:', err)
return true // Local cache succeeded
}
}
/**
* Removes the persistent link metadata from the sequence and cache,
* and deletes any markers that were synced from Shumai (matching Frame.io behavior).
*/
export async function removeSequenceLink(project: Project, sequence: Sequence): Promise<boolean> {
const ppro = getPremiereModule()
const seqGuidStr = normalizeGuid(sequence.guid)
const prGuidStr = project.guid ? normalizeGuid(project.guid) : null
console.log('[linkStorage] removeSequenceLink called for sequence:', sequence.name || seqGuidStr)
// Retrieve link metadata before clearing, to identify synced marker GUIDs
let linkData = await getSequenceLink(sequence, project)
if (!linkData) {
const cached = getAllSequenceLinksFromCache(prGuidStr)
linkData = cached.find((item) => normalizeGuid(item.sequenceGuid) === seqGuidStr) || null
}
console.log(
'[linkStorage] Retrieved linkData:',
linkData ? { assetId: linkData.assetId, guidsCount: linkData.syncedMarkerGuids?.length } : null,
)
// Remove from cache
removeSequenceLinkFromCache(seqGuidStr, prGuidStr)
// Remove synced markers from the sequence timeline
if (ppro?.Markers) {
try {
const sequenceMarkers = await ppro.Markers.getMarkers(sequence)
const allMarkers = sequenceMarkers.getMarkers() || []
console.log('[linkStorage] Found', allMarkers.length, 'markers on sequence timeline')
const targetGuids = new Set(
(linkData?.syncedMarkerGuids || []).map(normalizeGuid).filter(Boolean),
)
console.log('[linkStorage] targetGuids count:', targetGuids.size)
const markersToRemove: Marker[] = []
// 1. Match markers by GUID
if (targetGuids.size > 0) {
for (const m of allMarkers) {
const g = normalizeGuid(m.guid)
if (g && targetGuids.has(g)) {
markersToRemove.push(m)
}
}
}
// 2. Fallback: If targetGuids was empty/missing or didn't find markers, match by asset comments
if (markersToRemove.length === 0 && linkData?.assetId) {
console.log(
'[linkStorage] Fallback: attempting comment-based marker identification for asset:',
linkData.assetId,
)
try {
const creds = getStoredCredentials()
const canFetchComments =
creds?.endpoint &&
creds?.apiKey &&
(!linkData.endpoint || isSameEndpoint(linkData.endpoint, creds.endpoint))
if (canFetchComments) {
const comments = await fetchAssetComments(
creds.endpoint,
creds.apiKey,
linkData.assetId,
)
for (const comm of comments) {
const commBody = formatCommentBody(comm)
const commAuthor = comm.creator?.name || 'Comment'
for (const m of allMarkers) {
if (markersToRemove.includes(m)) continue
try {
const mName = m.getName()
const mComments = m.getComments()
if (
(mName === commAuthor && mComments === commBody) ||
(mComments && comm.message && mComments.includes(comm.message))
) {
markersToRemove.push(m)
break
}
} catch {
// ignore
}
}
}
}
} catch (err) {
console.warn('[linkStorage] Fallback comment fetch failed:', err)
}
}
console.log('[linkStorage] Total markers to remove:', markersToRemove.length)
if (markersToRemove.length > 0) {
let removeSuccess = false
try {
project.lockedAccess(() => {
removeSuccess = project.executeTransaction((compoundAction) => {
for (const marker of markersToRemove) {
const removeAction = sequenceMarkers.createRemoveMarkerAction(marker)
compoundAction.addAction(removeAction)
}
}, 'Remove Shumai Synced Markers')
})
} catch (err) {
console.error('[linkStorage] executeTransaction batch remove failed:', err)
}
console.log('[linkStorage] Batch remove result:', removeSuccess)
// If batch compound action did not succeed, attempt individual removals
if (!removeSuccess) {
console.warn('[linkStorage] Batch remove returned false, attempting individual removals')
for (const marker of markersToRemove) {
try {
project.lockedAccess(() => {
project.executeTransaction((compoundAction) => {
const removeAction = sequenceMarkers.createRemoveMarkerAction(marker)
compoundAction.addAction(removeAction)
}, 'Remove Shumai Synced Marker')
})
} catch (indErr) {
console.warn('[linkStorage] Failed individual remove:', indErr)
}
}
}
}
} catch (err) {
console.warn('[linkStorage] Failed to remove synced markers from sequence:', err)
}
}
if (!ppro?.Properties) {
return true
}
try {
const properties = await ppro.Properties.getProperties(sequence)
let success = false
project.lockedAccess(() => {
success = project.executeTransaction((compoundAction) => {
const clearAction = properties.createClearValueAction(LINK_STORAGE_PROP_KEY)
compoundAction.addAction(clearAction)
}, 'Unlink Shumai Asset')
})
console.log('[linkStorage] Clear property result:', success)
return success
} catch (err) {
console.warn('[linkStorage] Failed to clear sequence persistent property:', err)
return true // Cache was cleared
}
}
@@ -0,0 +1,405 @@
import { describe, it, expect, vi, beforeEach } from 'vitest'
import { formatCommentBody, syncCommentsToSequence } from './markers'
import type { Project, Sequence } from '@adobe/premierepro'
import type { CommentInfo } from '@shumai/dtos'
import type { LinkedSequenceAsset } from '../types/link'
const localStorageMock = (() => {
let store: Record<string, string> = {}
return {
getItem: (key: string) => store[key] || null,
setItem: (key: string, value: string) => {
store[key] = value.toString()
},
removeItem: (key: string) => {
delete store[key]
},
clear: () => {
store = {}
},
}
})()
Object.defineProperty(globalThis, 'localStorage', {
value: localStorageMock,
configurable: true,
writable: true,
})
describe('markers service', () => {
beforeEach(() => {
localStorage.clear()
vi.restoreAllMocks()
// Reset global require
// eslint-disable-next-line @typescript-eslint/no-explicit-any
delete (globalThis as any).require
// eslint-disable-next-line @typescript-eslint/no-explicit-any
delete (globalThis as any).window
})
describe('formatCommentBody', () => {
it('formats simple comment without replies', () => {
const comment: Partial<CommentInfo> = {
message: 'This is a test comment',
replies: [],
}
expect(formatCommentBody(comment as CommentInfo)).toBe('This is a test comment')
})
it('appends formatted replies beneath message', () => {
const comment: Partial<CommentInfo> = {
message: 'Original cut feedback',
replies: [
{
creator: { id: 'u2', name: 'Alice' },
message: 'Fixed in v2',
} as unknown as CommentInfo,
{
creator: { id: 'u3', name: 'Bob' },
message: 'Looks great now',
} as unknown as CommentInfo,
],
}
const formatted = formatCommentBody(comment as CommentInfo)
expect(formatted).toContain('Original cut feedback')
expect(formatted).toContain('--- Replies ---')
expect(formatted).toContain('Alice: Fixed in v2')
expect(formatted).toContain('Bob: Looks great now')
})
})
describe('syncCommentsToSequence', () => {
const existingLink: LinkedSequenceAsset = {
sequenceGuid: 'seq-guid-1',
sequenceName: 'Seq 1',
assetId: 'asset-1',
assetName: 'test.mp4',
syncedCommentIds: ['comm-1'],
lastSyncAt: 1000,
totalCommentsSynced: 1,
}
it('returns without creating markers if no new comments exist', async () => {
const comments: Partial<CommentInfo>[] = [
{ id: 'comm-1', second: 10, message: 'Already synced' },
]
const mockProject = {
guid: 'proj-1',
lockedAccess: vi.fn(),
executeTransaction: vi.fn(),
}
const mockSeq = { guid: 'seq-guid-1' }
const result = await syncCommentsToSequence(
mockProject as unknown as Project,
mockSeq as unknown as Sequence,
comments as CommentInfo[],
existingLink,
)
expect(result.addedCount).toBe(0)
expect(result.updatedLink.syncedCommentIds).toEqual(['comm-1'])
expect(mockProject.executeTransaction).not.toHaveBeenCalled()
})
it('creates markers for new comments, placing non-timestamped comments at time 0 (zeroPoint)', async () => {
const mockCompoundAction = { addAction: vi.fn() }
let callCount = 0
const mockSeqMarkers = {
getMarkers: vi.fn().mockImplementation(() => {
callCount++
if (callCount === 1) {
return [{ guid: 'old-guid-1' }]
}
return [{ guid: 'old-guid-1' }, { guid: 'marker-guid-2' }, { guid: 'marker-guid-3' }]
}),
createAddMarkerAction: vi.fn().mockImplementation((name, type, time, dur, comment) => {
return { name, type, time, dur, comment }
}),
}
const mockPpro = {
Marker: { MARKER_TYPE_COMMENT: 'CommentMarkerType' },
Markers: {
getMarkers: vi.fn().mockResolvedValue(mockSeqMarkers),
},
TickTime: {
TIME_ZERO: { ticks: '0' },
createWithSeconds: vi.fn((sec) => ({ seconds: sec })),
},
Properties: {
getProperties: vi.fn().mockResolvedValue({
createSetValueAction: vi.fn().mockReturnValue({}),
}),
},
}
// eslint-disable-next-line @typescript-eslint/no-explicit-any
;(globalThis as any).window = {
require: vi.fn().mockImplementation((name: string) => {
if (name === 'premierepro') return mockPpro
return null
}),
}
const comments: Partial<CommentInfo>[] = [
{ id: 'comm-1', second: 10, message: 'Already synced' },
{
id: 'comm-2',
second: 15.5,
message: 'New timestamped comment',
creator: { id: 'u1', name: 'Director' } as unknown as CommentInfo['creator'],
replies: [],
},
{
id: 'comm-3',
second: null,
message: 'General comment without timestamp',
creator: { id: 'u2', name: 'Producer' } as unknown as CommentInfo['creator'],
replies: [],
},
]
const mockProject = {
guid: 'proj-1',
lockedAccess: vi.fn((cb) => cb()),
executeTransaction: vi.fn((cb) => {
cb(mockCompoundAction)
return true
}),
}
const mockSeq = {
guid: 'seq-guid-1',
getZeroPoint: vi.fn().mockResolvedValue({ seconds: 3600 }), // 1hr timecode start
}
const result = await syncCommentsToSequence(
mockProject as unknown as Project,
mockSeq as unknown as Sequence,
comments as CommentInfo[],
existingLink,
)
expect(result.addedCount).toBe(2)
expect(result.updatedLink.syncedCommentIds).toEqual(['comm-1', 'comm-2', 'comm-3'])
expect(result.updatedLink.syncedMarkerGuids).toEqual(['marker-guid-2', 'marker-guid-3'])
expect(result.updatedLink.totalCommentsSynced).toBe(3)
// Time should be offset by zeroPoint (3600 + 15.5 = 3615.5 for comm-2, 3600 + 0 = 3600 for comm-3)
expect(mockPpro.TickTime.createWithSeconds).toHaveBeenCalledWith(3615.5)
expect(mockPpro.TickTime.createWithSeconds).toHaveBeenCalledWith(3600)
expect(mockSeqMarkers.createAddMarkerAction).toHaveBeenCalledWith(
'Director',
'CommentMarkerType',
{ seconds: 3615.5 },
mockPpro.TickTime.TIME_ZERO,
'New timestamped comment',
)
expect(mockSeqMarkers.createAddMarkerAction).toHaveBeenCalledWith(
'Producer',
'CommentMarkerType',
{ seconds: 3600 },
mockPpro.TickTime.TIME_ZERO,
'General comment without timestamp',
)
expect(mockSeqMarkers.createAddMarkerAction).toHaveBeenCalledTimes(2)
expect(mockCompoundAction.addAction).toHaveBeenCalled()
})
it('backfills missing marker GUIDs from sequence when syncedMarkerGuids is incomplete', async () => {
const existingLink: LinkedSequenceAsset = {
sequenceGuid: 'seq-guid-1',
sequenceName: 'Sequence 01',
assetId: 'asset-1',
assetName: 'video.mp4',
syncedCommentIds: ['comm-1'],
syncedMarkerGuids: [], // missing GUIDs from previous sync
totalCommentsSynced: 1,
lastSyncAt: 1000,
}
const mockLegacyMarker = {
guid: '{LEGACY-MARKER-GUID-1}',
getName: () => 'Director',
getComments: () => 'Existing comment message',
}
const mockSeqMarkers = {
getMarkers: vi.fn().mockReturnValue([mockLegacyMarker]),
createAddMarkerAction: vi.fn(),
}
const mockPpro = {
Marker: { MARKER_TYPE_COMMENT: 'CommentMarkerType' },
Markers: {
getMarkers: vi.fn().mockResolvedValue(mockSeqMarkers),
},
TickTime: {
TIME_ZERO: { ticks: '0' },
createWithSeconds: vi.fn((sec) => ({ seconds: sec })),
},
Properties: {
getProperties: vi.fn().mockResolvedValue({
createSetValueAction: vi.fn().mockReturnValue({}),
}),
},
}
// eslint-disable-next-line @typescript-eslint/no-explicit-any
;(globalThis as any).window = {
require: vi.fn().mockImplementation((name: string) => {
if (name === 'premierepro') return mockPpro
return null
}),
}
const comments: Partial<CommentInfo>[] = [
{
id: 'comm-1',
second: 10,
message: 'Existing comment message',
creator: { id: 'u1', name: 'Director' } as unknown as CommentInfo['creator'],
replies: [],
},
]
const mockProject = {
guid: 'proj-1',
lockedAccess: vi.fn((cb) => cb()),
executeTransaction: vi.fn(),
}
const mockSeq = {
guid: 'seq-guid-1',
getZeroPoint: vi.fn().mockResolvedValue({ seconds: 0 }),
}
const result = await syncCommentsToSequence(
mockProject as unknown as Project,
mockSeq as unknown as Sequence,
comments as CommentInfo[],
existingLink,
)
expect(result.addedCount).toBe(0)
expect(result.updatedLink.syncedMarkerGuids).toEqual(['legacy-marker-guid-1'])
expect(mockSeqMarkers.createAddMarkerAction).not.toHaveBeenCalled()
})
it('does not advance synced comments when executeTransaction returns false', async () => {
const mockSeqMarkers = {
getMarkers: vi.fn().mockReturnValue([]),
createAddMarkerAction: vi.fn().mockReturnValue({}),
}
const mockPpro = {
Marker: { MARKER_TYPE_COMMENT: 'CommentMarkerType' },
Markers: {
getMarkers: vi.fn().mockResolvedValue(mockSeqMarkers),
},
TickTime: {
TIME_ZERO: { ticks: '0' },
createWithSeconds: vi.fn((sec) => ({ seconds: sec })),
},
Properties: {
getProperties: vi.fn().mockResolvedValue({
createSetValueAction: vi.fn().mockReturnValue({}),
}),
},
}
// eslint-disable-next-line @typescript-eslint/no-explicit-any
;(globalThis as any).window = {
require: vi.fn().mockImplementation((name: string) => {
if (name === 'premierepro') return mockPpro
return null
}),
}
const comments: Partial<CommentInfo>[] = [
{ id: 'comm-1', second: 10, message: 'Already synced' },
{ id: 'comm-2', second: 20, message: 'New comment' },
]
const mockProject = {
guid: 'proj-1',
lockedAccess: vi.fn((cb) => cb()),
executeTransaction: vi.fn().mockReturnValue(false),
}
const mockSeq = {
guid: 'seq-guid-1',
getZeroPoint: vi.fn().mockResolvedValue({ seconds: 0 }),
}
const result = await syncCommentsToSequence(
mockProject as unknown as Project,
mockSeq as unknown as Sequence,
comments as CommentInfo[],
existingLink,
)
expect(result.addedCount).toBe(0)
expect(result.updatedLink.syncedCommentIds).toEqual(['comm-1'])
expect(result.updatedLink.totalCommentsSynced).toBe(1)
})
it('does not advance synced comments when executeTransaction throws an error', async () => {
const mockSeqMarkers = {
getMarkers: vi.fn().mockReturnValue([]),
createAddMarkerAction: vi.fn().mockReturnValue({}),
}
const mockPpro = {
Marker: { MARKER_TYPE_COMMENT: 'CommentMarkerType' },
Markers: {
getMarkers: vi.fn().mockResolvedValue(mockSeqMarkers),
},
TickTime: {
TIME_ZERO: { ticks: '0' },
createWithSeconds: vi.fn((sec) => ({ seconds: sec })),
},
Properties: {
getProperties: vi.fn().mockResolvedValue({
createSetValueAction: vi.fn().mockReturnValue({}),
}),
},
}
// eslint-disable-next-line @typescript-eslint/no-explicit-any
;(globalThis as any).window = {
require: vi.fn().mockImplementation((name: string) => {
if (name === 'premierepro') return mockPpro
return null
}),
}
const comments: Partial<CommentInfo>[] = [
{ id: 'comm-1', second: 10, message: 'Already synced' },
{ id: 'comm-2', second: 20, message: 'New comment' },
]
const mockProject = {
guid: 'proj-1',
lockedAccess: vi.fn(() => {
throw new Error('Transaction execution crashed')
}),
executeTransaction: vi.fn(),
}
const mockSeq = {
guid: 'seq-guid-1',
getZeroPoint: vi.fn().mockResolvedValue({ seconds: 0 }),
}
const result = await syncCommentsToSequence(
mockProject as unknown as Project,
mockSeq as unknown as Sequence,
comments as CommentInfo[],
existingLink,
)
expect(result.addedCount).toBe(0)
expect(result.updatedLink.syncedCommentIds).toEqual(['comm-1'])
expect(result.updatedLink.totalCommentsSynced).toBe(1)
})
})
})
+179
View File
@@ -0,0 +1,179 @@
import type { Project, Sequence } from '@adobe/premierepro'
import { getPremiereModule } from './premiere'
import type { LinkedSequenceAsset } from '../types/link'
import { normalizeGuid, saveSequenceLink } from './linkStorage'
import type { CommentInfo } from '@shumai/dtos'
import { fetchAssetComments, formatCommentBody } from './commentUtils'
export { fetchAssetComments, formatCommentBody }
export interface SyncCommentsResult {
updatedLink: LinkedSequenceAsset
addedCount: number
}
/**
* Synchronizes new Shumai comments to a Premiere Pro sequence as markers.
* Comments without timestamps (`second == null`) default to time 0 (sequence start),
* matching Frame.io convention. Newly created marker GUIDs are captured and stored
* so they can be accurately removed when the sequence is unlinked.
*/
export async function syncCommentsToSequence(
project: Project,
sequence: Sequence,
comments: CommentInfo[],
existingLink: LinkedSequenceAsset,
): Promise<SyncCommentsResult> {
const ppro = getPremiereModule()
const now = Date.now()
// Filter comments that have not been synced yet; non-timestamped comments default to time 0
const alreadySyncedSet = new Set(existingLink.syncedCommentIds)
const newComments = comments.filter((c) => !alreadySyncedSet.has(c.id))
const currentMarkerGuids = (existingLink.syncedMarkerGuids || [])
.map(normalizeGuid)
.filter(Boolean)
const needsGuidBackfill =
currentMarkerGuids.length < (existingLink.syncedCommentIds?.length || 0) &&
ppro?.Markers != null
if (newComments.length === 0 && !needsGuidBackfill) {
const updatedLink: LinkedSequenceAsset = {
...existingLink,
lastSyncAt: now,
}
await saveSequenceLink(project, sequence, updatedLink)
return { updatedLink, addedCount: 0 }
}
if (!ppro?.Markers || !ppro?.TickTime) {
console.warn('[markers] premierepro Markers or TickTime module not available')
return { updatedLink: existingLink, addedCount: 0 }
}
const newMarkerGuids: string[] = []
try {
const sequenceMarkers = await ppro.Markers.getMarkers(sequence)
let zeroPointSeconds = 0
try {
const zeroPoint = await sequence.getZeroPoint()
if (zeroPoint && typeof zeroPoint.seconds === 'number') {
zeroPointSeconds = zeroPoint.seconds
}
} catch {
// zeroPoint defaults to 0
}
// Capture existing marker GUIDs before adding new markers
let beforeGuids = new Set<string>()
try {
const beforeMarkers = sequenceMarkers.getMarkers() || []
beforeGuids = new Set(beforeMarkers.map((m) => normalizeGuid(m.guid)).filter(Boolean))
console.log('[markers] Existing markers before sync:', beforeMarkers.length)
} catch (err) {
console.warn('[markers] Could not get existing markers before sync:', err)
}
if (newComments.length > 0) {
let txSuccess = false
project.lockedAccess(() => {
txSuccess =
project.executeTransaction((compoundAction) => {
for (const comment of newComments) {
const markerSeconds = zeroPointSeconds + (comment.second ?? 0)
const startTime = ppro.TickTime.createWithSeconds(markerSeconds)
const duration = ppro.TickTime.TIME_ZERO
const markerName = comment.creator?.name || 'Comment'
const markerText = formatCommentBody(comment)
const addMarkerAction = sequenceMarkers.createAddMarkerAction(
markerName,
ppro.Marker.MARKER_TYPE_COMMENT,
startTime,
duration,
markerText,
)
compoundAction.addAction(addMarkerAction)
}
}, 'Sync Shumai Comments') === true
})
console.log('[markers] executeTransaction result:', txSuccess)
if (!txSuccess) {
console.warn('[markers] Failed to execute add markers transaction (returned false)')
return { updatedLink: existingLink, addedCount: 0 }
}
}
// Re-fetch fresh Markers object after transaction to ensure newly committed markers are seen
const freshSequenceMarkers = await ppro.Markers.getMarkers(sequence)
const afterMarkers = freshSequenceMarkers.getMarkers() || []
console.log('[markers] Markers after sync transaction:', afterMarkers.length)
// 1. Identify newly added markers by GUID difference
for (const m of afterMarkers) {
const guidStr = normalizeGuid(m.guid)
if (guidStr && !beforeGuids.has(guidStr) && !newMarkerGuids.includes(guidStr)) {
newMarkerGuids.push(guidStr)
}
}
// 2. Fallback / Backfill: Match any comment markers by content/author
const allExpectedComments = [...newComments]
if (needsGuidBackfill) {
const alreadySyncedComments = comments.filter((c) => alreadySyncedSet.has(c.id))
allExpectedComments.push(...alreadySyncedComments)
}
const currentKnownGuids = new Set([...currentMarkerGuids, ...newMarkerGuids])
for (const comment of allExpectedComments) {
const commentBody = formatCommentBody(comment)
const commentAuthor = comment.creator?.name || 'Comment'
for (const m of afterMarkers) {
const g = normalizeGuid(m.guid)
if (!g || currentKnownGuids.has(g)) continue
try {
const mName = m.getName()
const mComments = m.getComments()
if (
(mName === commentAuthor && mComments === commentBody) ||
(mComments && comment.message && mComments.includes(comment.message))
) {
newMarkerGuids.push(g)
currentKnownGuids.add(g)
break
}
} catch {
// ignore
}
}
}
console.log(
'[markers] Total newly captured/backfilled marker GUIDs:',
newMarkerGuids.length,
newMarkerGuids,
)
const updatedMarkerGuids = Array.from(
new Set([...currentMarkerGuids, ...newMarkerGuids.map(normalizeGuid)]),
)
const updatedLink: LinkedSequenceAsset = {
...existingLink,
syncedCommentIds: [...existingLink.syncedCommentIds, ...newComments.map((c) => c.id)],
syncedMarkerGuids: updatedMarkerGuids,
totalCommentsSynced: existingLink.totalCommentsSynced + newComments.length,
lastSyncAt: now,
}
await saveSequenceLink(project, sequence, updatedLink)
return { updatedLink, addedCount: newComments.length }
} catch (err) {
console.error('[markers] Failed to execute add markers transaction:', err)
return { updatedLink: existingLink, addedCount: 0 }
}
}
@@ -0,0 +1,248 @@
import { describe, it, expect, vi, beforeEach } from 'vitest'
import {
getActiveProject,
importFilesIntoProject,
promptSelectFolder,
promptSaveFile,
writeBinaryFile,
getPremiereModule,
getUxpModule,
} from './premiere'
import type { Project, Sequence } from '@adobe/premierepro'
describe('premiere service', () => {
beforeEach(() => {
vi.restoreAllMocks()
// Reset any global require mocks on globalThis
// eslint-disable-next-line @typescript-eslint/no-explicit-any
delete (globalThis as any).require
// Reset window mock on globalThis
// eslint-disable-next-line @typescript-eslint/no-explicit-any
delete (globalThis as any).window
})
describe('module getters', () => {
it('returns null when premierepro is not available', () => {
expect(getPremiereModule()).toBeNull()
})
it('returns null when uxp is not available', () => {
expect(getUxpModule()).toBeNull()
})
it('resolves premiere module from global require when present', () => {
const mockPpro = { Project: { getActiveProject: vi.fn() } }
// Mocking UXP window environment on globalThis
// eslint-disable-next-line @typescript-eslint/no-explicit-any
;(globalThis as any).window = {
require: vi.fn().mockImplementation((name: string) => {
if (name === 'premierepro') return mockPpro
return null
}),
}
expect(getPremiereModule()).toBe(mockPpro)
})
})
describe('getActiveProject', () => {
it('returns null when module is missing', async () => {
const project = await getActiveProject()
expect(project).toBeNull()
})
it('returns active project when available', async () => {
const mockProject = { name: 'MyProject.prproj' }
// Mocking UXP window environment on globalThis
// eslint-disable-next-line @typescript-eslint/no-explicit-any
;(globalThis as any).window = {
require: vi.fn().mockImplementation((name: string) => {
if (name === 'premierepro') {
return {
Project: {
getActiveProject: vi.fn().mockResolvedValue(mockProject),
},
}
}
return null
}),
}
const project = await getActiveProject()
expect(project).toBe(mockProject)
})
})
describe('importFilesIntoProject', () => {
it('returns false when filePaths is empty', async () => {
const project = { importFiles: vi.fn() } as unknown as Project
const success = await importFilesIntoProject(project, [])
expect(success).toBe(false)
expect(project.importFiles).not.toHaveBeenCalled()
})
it('calls project.importFiles with suppressUI true', async () => {
const project = {
importFiles: vi.fn().mockResolvedValue(true),
} as unknown as Project
const success = await importFilesIntoProject(project, ['/path/to/video.mp4'])
expect(success).toBe(true)
expect(project.importFiles).toHaveBeenCalledWith(['/path/to/video.mp4'], true, null, false)
})
it('handles import error gracefully', async () => {
const project = {
importFiles: vi.fn().mockRejectedValue(new Error('Import failed in host')),
} as unknown as Project
const success = await importFilesIntoProject(project, ['/path/to/video.mp4'])
expect(success).toBe(false)
})
})
describe('promptSelectFolder', () => {
it('throws when UXP storage is unavailable', async () => {
await expect(promptSelectFolder()).rejects.toThrow('UXP storage')
})
it('delegates to uxp.storage.localFileSystem.getFolder', async () => {
const mockFolder: UxpFolderEntry = {
isFile: false,
isFolder: true,
name: 'Downloads',
nativePath: '/Users/test/Downloads',
createFile: vi.fn(),
getEntries: vi.fn().mockResolvedValue([]),
}
// Mocking UXP window environment on globalThis
// eslint-disable-next-line @typescript-eslint/no-explicit-any
;(globalThis as any).window = {
require: vi.fn().mockImplementation((name: string) => {
if (name === 'uxp') {
return {
storage: {
localFileSystem: {
getFolder: vi.fn().mockResolvedValue(mockFolder),
},
},
}
}
return null
}),
}
const folder = await promptSelectFolder()
expect(folder).toBe(mockFolder)
})
})
describe('promptSaveFile', () => {
it('throws when UXP storage is unavailable', async () => {
await expect(promptSaveFile('test.mp4')).rejects.toThrow('UXP storage')
})
it('delegates to uxp.storage.localFileSystem.getFileForSaving', async () => {
const mockFile: UxpFileEntry = {
isFile: true,
isFolder: false,
name: 'test.mp4',
nativePath: '/path/test.mp4',
write: vi.fn(),
}
// Mocking UXP window environment on globalThis
// eslint-disable-next-line @typescript-eslint/no-explicit-any
;(globalThis as any).window = {
require: vi.fn().mockImplementation((name: string) => {
if (name === 'uxp') {
return {
storage: {
localFileSystem: {
getFileForSaving: vi.fn().mockResolvedValue(mockFile),
},
},
}
}
return null
}),
}
const file = await promptSaveFile('test.mp4')
expect(file).toBe(mockFile)
})
})
describe('writeBinaryFile', () => {
it('calls file.write with binary format option', async () => {
const mockFile: UxpFileEntry = {
isFile: true,
isFolder: false,
name: 'test.mp4',
nativePath: '/path/test.mp4',
write: vi.fn().mockResolvedValue(undefined),
}
// Mocking UXP window environment on globalThis
// eslint-disable-next-line @typescript-eslint/no-explicit-any
;(globalThis as any).window = {
require: vi.fn().mockImplementation((name: string) => {
if (name === 'uxp') {
return {
storage: {
formats: { binary: 'binary-format-token' },
},
}
}
return null
}),
}
const dummyBuffer = new ArrayBuffer(16)
await writeBinaryFile(mockFile, dummyBuffer)
expect(mockFile.write).toHaveBeenCalledWith(dummyBuffer, { format: 'binary-format-token' })
})
})
describe('sequence functions', () => {
it('getActiveSequence returns active sequence from project', async () => {
const { getActiveSequence } = await import('./premiere')
const mockSeq = { name: 'Seq 1', guid: 'guid-1' }
const mockProject = {
getActiveSequence: vi.fn().mockResolvedValue(mockSeq),
}
const seq = await getActiveSequence(mockProject as unknown as Project)
expect(seq).toBe(mockSeq)
})
it('getAllSequences returns array of sequences', async () => {
const { getAllSequences } = await import('./premiere')
const mockSeq1 = { name: 'Seq 1', guid: 'guid-1' }
const mockSeq2 = { name: 'Seq 2', guid: 'guid-2' }
const mockProject = {
getSequences: vi.fn().mockResolvedValue([mockSeq1, mockSeq2]),
}
const seqs = await getAllSequences(mockProject as unknown as Project)
expect(seqs).toHaveLength(2)
expect(seqs[0].name).toBe('Seq 1')
})
it('openSequenceInTimeline opens and activates sequence', async () => {
const { openSequenceInTimeline } = await import('./premiere')
const mockSeq = { name: 'Seq 1', guid: 'guid-1' }
const mockProject = {
openSequence: vi.fn().mockResolvedValue(true),
setActiveSequence: vi.fn().mockResolvedValue(true),
}
const result = await openSequenceInTimeline(
mockSeq as unknown as Sequence,
mockProject as unknown as Project,
)
expect(result).toBe(true)
expect(mockProject.openSequence).toHaveBeenCalledWith(mockSeq)
expect(mockProject.setActiveSequence).toHaveBeenCalledWith(mockSeq)
})
})
})
+178
View File
@@ -0,0 +1,178 @@
import type { Project, Sequence, premierepro } from '@adobe/premierepro'
/**
* Safely resolves the Premiere Pro host module (`premierepro`).
*/
export function getPremiereModule(): premierepro | null {
try {
// In UXP, host modules are available via require()
if (typeof window !== 'undefined' && 'require' in window) {
// Dynamic runtime property injected on window by Adobe UXP
// eslint-disable-next-line @typescript-eslint/no-explicit-any
return (window as any).require('premierepro')
}
if (typeof require !== 'undefined') {
// Adobe UXP host modules must be resolved dynamically at runtime via CommonJS require
// eslint-disable-next-line @typescript-eslint/no-require-imports
return require('premierepro')
}
} catch (err) {
console.warn('[UXP] premierepro module not available:', err)
}
return null
}
/**
* Safely resolves the UXP environment module (`uxp`).
*/
export function getUxpModule(): UxpModule | null {
try {
if (typeof window !== 'undefined' && 'require' in window) {
// Dynamic runtime property injected on window by Adobe UXP
// eslint-disable-next-line @typescript-eslint/no-explicit-any
return (window as any).require('uxp')
}
if (typeof require !== 'undefined') {
// Adobe UXP host modules must be resolved dynamically at runtime via CommonJS require
// eslint-disable-next-line @typescript-eslint/no-require-imports
return require('uxp')
}
} catch (err) {
console.warn('[UXP] uxp module not available:', err)
}
return null
}
/**
* Retrieves the currently active project in Premiere Pro.
*/
export async function getActiveProject(): Promise<Project | null> {
const ppro = getPremiereModule()
if (!ppro?.Project) {
return null
}
try {
return await ppro.Project.getActiveProject()
} catch (err) {
console.error('Failed to get active project:', err)
return null
}
}
/**
* Retrieves the currently active sequence of the project.
*/
export async function getActiveSequence(project?: Project | null): Promise<Sequence | null> {
const pr = project || (await getActiveProject())
if (!pr) return null
try {
const seq = await pr.getActiveSequence()
return seq || null
} catch (err) {
console.error('Failed to get active sequence:', err)
return null
}
}
/**
* Retrieves all sequences in the project.
*/
export async function getAllSequences(project?: Project | null): Promise<Sequence[]> {
const pr = project || (await getActiveProject())
if (!pr) return []
try {
const seqs = await pr.getSequences()
return seqs || []
} catch (err) {
console.error('Failed to get all sequences:', err)
return []
}
}
/**
* Opens and activates a sequence in the Premiere Pro timeline.
*/
export async function openSequenceInTimeline(
sequence: Sequence,
project?: Project | null,
): Promise<boolean> {
const pr = project || (await getActiveProject())
if (!pr) return false
try {
const opened = await pr.openSequence(sequence)
try {
await pr.setActiveSequence(sequence)
} catch {
// setActiveSequence may not be required if openSequence already focuses it
}
return opened ?? true
} catch (err) {
console.error('Failed to open sequence in timeline:', err)
return false
}
}
/**
* Imports one or more files into the Premiere Pro project root.
*/
export async function importFilesIntoProject(
project: Project,
filePaths: string[],
): Promise<boolean> {
if (!filePaths.length) return false
try {
return await project.importFiles(
filePaths,
true, // suppressUI
// @ts-expect-error Premiere Pro UXP requires null instead of undefined to default to project root
null, // targetBin; `null` defaults to project root
false, // asNumberedStills
)
} catch (err) {
console.error('Failed to import files into Premiere project:', err)
return false
}
}
/**
* Opens the native OS folder picker to ask the user where to save files.
* Returns the selected UxpFolderEntry, or null if the user cancelled.
*/
export async function promptSelectFolder(): Promise<UxpFolderEntry | null> {
const uxp = getUxpModule()
if (!uxp?.storage?.localFileSystem) {
throw new Error('UXP storage.localFileSystem is not available.')
}
try {
return await uxp.storage.localFileSystem.getFolder()
} catch (err) {
console.error('Error in promptSelectFolder:', err)
return null
}
}
/**
* Opens the native OS file picker to ask the user where to save a file.
* Returns the selected UxpFileEntry, or null if the user cancelled.
*/
export async function promptSaveFile(defaultName: string): Promise<UxpFileEntry | null> {
const uxp = getUxpModule()
if (!uxp?.storage?.localFileSystem) {
throw new Error('UXP storage.localFileSystem is not available.')
}
try {
return await uxp.storage.localFileSystem.getFileForSaving(defaultName)
} catch (err) {
console.error('Error in promptSaveFile:', err)
return null
}
}
/**
* Writes an ArrayBuffer into a UXP File entry as binary.
*/
export async function writeBinaryFile(file: UxpFileEntry, data: ArrayBuffer): Promise<void> {
const uxp = getUxpModule()
const format = uxp?.storage?.formats?.binary
await file.write(data, { format })
}
@@ -0,0 +1,55 @@
import { describe, it, expect, beforeEach } from 'vitest'
import { getStoredCredentials, saveStoredCredentials, clearStoredCredentials } from './storage'
const localStorageMock = (() => {
let store: Record<string, string> = {}
return {
getItem: (key: string) => store[key] || null,
setItem: (key: string, value: string) => {
store[key] = value.toString()
},
removeItem: (key: string) => {
delete store[key]
},
clear: () => {
store = {}
},
}
})()
Object.defineProperty(globalThis, 'localStorage', {
value: localStorageMock,
configurable: true,
writable: true,
})
describe('Storage Service', () => {
beforeEach(() => {
localStorage.clear()
})
it('returns null when no credentials are stored', () => {
expect(getStoredCredentials()).toBeNull()
})
it('saves and retrieves credentials correctly', () => {
saveStoredCredentials('http://localhost:3000', 'test-api-key')
const creds = getStoredCredentials()
expect(creds).toEqual({
endpoint: 'http://localhost:3000',
apiKey: 'test-api-key',
})
})
it('normalizes endpoint URL by stripping trailing slashes', () => {
saveStoredCredentials('https://api.shumai.io///', 'test-api-key')
const creds = getStoredCredentials()
expect(creds?.endpoint).toBe('https://api.shumai.io')
})
it('clears stored credentials', () => {
saveStoredCredentials('http://localhost:3000', 'test-api-key')
clearStoredCredentials()
expect(getStoredCredentials()).toBeNull()
})
})
+38
View File
@@ -0,0 +1,38 @@
export interface StoredCredentials {
endpoint: string
apiKey: string
}
const STORAGE_KEY_ENDPOINT = 'shumai_uxp_endpoint'
const STORAGE_KEY_API_KEY = 'shumai_uxp_api_key'
export function getStoredCredentials(): StoredCredentials | null {
try {
const endpoint = localStorage.getItem(STORAGE_KEY_ENDPOINT)
const apiKey = localStorage.getItem(STORAGE_KEY_API_KEY)
if (endpoint && apiKey) {
return { endpoint, apiKey }
}
} catch (err) {
console.error('Failed to read credentials from localStorage:', err)
}
return null
}
export function saveStoredCredentials(endpoint: string, apiKey: string): void {
try {
localStorage.setItem(STORAGE_KEY_ENDPOINT, endpoint.trim().replace(/\/+$/, ''))
localStorage.setItem(STORAGE_KEY_API_KEY, apiKey.trim())
} catch (err) {
console.error('Failed to save credentials to localStorage:', err)
}
}
export function clearStoredCredentials(): void {
try {
localStorage.removeItem(STORAGE_KEY_ENDPOINT)
localStorage.removeItem(STORAGE_KEY_API_KEY)
} catch (err) {
console.error('Failed to clear credentials from localStorage:', err)
}
}
+13
View File
@@ -0,0 +1,13 @@
export interface LinkedSequenceAsset {
sequenceGuid: string
sequenceName: string
assetId: string
assetName: string
assetThumbnailUrl?: string
endpoint?: string
projectId?: string
syncedCommentIds: string[]
syncedMarkerGuids?: string[]
lastSyncAt: number
totalCommentsSynced: number
}
+27
View File
@@ -0,0 +1,27 @@
export function formatDateAgo(dateInput?: string | number | Date | null): string {
if (!dateInput) return ''
const date =
typeof dateInput === 'string' || typeof dateInput === 'number' ? new Date(dateInput) : dateInput
if (isNaN(date.getTime())) return ''
const now = new Date()
const diffSec = Math.max(0, Math.floor((now.getTime() - date.getTime()) / 1000))
if (diffSec < 60) return 'just now'
const diffMin = Math.floor(diffSec / 60)
if (diffMin < 60) return `${diffMin}m ago`
const diffHours = Math.floor(diffMin / 60)
if (diffHours < 24) return `${diffHours}h ago`
const diffDays = Math.floor(diffHours / 24)
if (diffDays === 1) return 'yesterday'
if (diffDays < 30) return `${diffDays}d ago`
const diffMonths = Math.floor(diffDays / 30)
if (diffMonths < 12) return `${diffMonths}mo ago`
const diffYears = Math.floor(diffMonths / 12)
return `${diffYears}y ago`
}
@@ -0,0 +1,44 @@
import { describe, it, expect } from 'vitest'
import { formatBytes, formatDuration } from './format'
describe('formatBytes', () => {
it('handles null, undefined, 0 and invalid inputs', () => {
expect(formatBytes(null)).toBe('0 B')
expect(formatBytes(undefined)).toBe('0 B')
expect(formatBytes(0)).toBe('0 B')
expect(formatBytes(-100)).toBe('0 B')
expect(formatBytes(NaN)).toBe('0 B')
})
it('formats bytes correctly', () => {
expect(formatBytes(500)).toBe('500 B')
expect(formatBytes(1024)).toBe('1.0 KB')
expect(formatBytes(1536)).toBe('1.5 KB')
expect(formatBytes(1048576)).toBe('1.0 MB')
expect(formatBytes(1073741824)).toBe('1.0 GB')
})
})
describe('formatDuration', () => {
it('returns null for invalid or non-positive durations', () => {
expect(formatDuration(null)).toBeNull()
expect(formatDuration(undefined)).toBeNull()
expect(formatDuration(0)).toBeNull()
expect(formatDuration(-15)).toBeNull()
expect(formatDuration(NaN)).toBeNull()
})
it('formats seconds into MM:SS format', () => {
expect(formatDuration(5.4)).toBe('00:05')
expect(formatDuration(59)).toBe('00:59')
expect(formatDuration(60)).toBe('01:00')
expect(formatDuration(65)).toBe('01:05')
expect(formatDuration(3599)).toBe('59:59')
})
it('formats hours into H:MM:SS format', () => {
expect(formatDuration(3600)).toBe('1:00:00')
expect(formatDuration(3665)).toBe('1:01:05')
expect(formatDuration(36665)).toBe('10:11:05')
})
})
+26
View File
@@ -0,0 +1,26 @@
/**
* Formats a byte count into a human-readable size string (e.g. 1.2 MB, 450 KB).
*/
export function formatBytes(bytes?: number | null): string {
if (bytes == null || bytes === 0 || isNaN(bytes) || bytes < 0) return '0 B'
const units = ['B', 'KB', 'MB', 'GB', 'TB']
const i = Math.floor(Math.log(bytes) / Math.log(1024))
const safeIndex = Math.min(Math.max(0, i), units.length - 1)
return `${(bytes / Math.pow(1024, safeIndex)).toFixed(safeIndex === 0 ? 0 : 1)} ${units[safeIndex]}`
}
/**
* Formats duration in seconds into MM:SS or H:MM:SS format (e.g. 02:45, 1:12:30).
* Returns null if duration is invalid, zero or negative.
*/
export function formatDuration(seconds?: number | null): string | null {
if (seconds == null || isNaN(seconds) || seconds <= 0) return null
const totalSecs = Math.round(seconds)
const hours = Math.floor(totalSecs / 3600)
const minutes = Math.floor((totalSecs % 3600) / 60)
const secs = totalSecs % 60
if (hours > 0) {
return `${hours}:${minutes.toString().padStart(2, '0')}:${secs.toString().padStart(2, '0')}`
}
return `${minutes.toString().padStart(2, '0')}:${secs.toString().padStart(2, '0')}`
}
+72
View File
@@ -0,0 +1,72 @@
import { describe, it, expect } from 'vitest'
import { resolveAssetUrl, normalizeEndpoint, isSameEndpoint } from './url'
describe('resolveAssetUrl', () => {
it('returns undefined for empty or null inputs', () => {
expect(resolveAssetUrl(null, 'http://localhost:3000')).toBeUndefined()
expect(resolveAssetUrl(undefined, 'http://localhost:3000')).toBeUndefined()
expect(resolveAssetUrl('', 'http://localhost:3000')).toBeUndefined()
})
it('returns original url if endpoint is not provided', () => {
expect(resolveAssetUrl('/files/123')).toBe('/files/123')
expect(resolveAssetUrl('http://example.com/img.png')).toBe('http://example.com/img.png')
})
it('prepends endpoint to relative paths', () => {
expect(resolveAssetUrl('/files/shumai/cat.png', 'http://localhost:3000')).toBe(
'http://localhost:3000/files/shumai/cat.png',
)
expect(resolveAssetUrl('/files/shumai/cat.png', 'http://localhost:3000/')).toBe(
'http://localhost:3000/files/shumai/cat.png',
)
})
it('preserves absolute URLs intact even when hosts differ', () => {
const localRaw = 'http://localhost:3000/files/shumai/files/cat.webp'
const endpoint = 'http://127.0.0.1:3000'
expect(resolveAssetUrl(localRaw, endpoint)).toBe(localRaw)
const remoteEndpoint = 'https://shumai.example.com'
expect(resolveAssetUrl(localRaw, remoteEndpoint)).toBe(localRaw)
})
it('keeps matching absolute URLs intact', () => {
const raw = 'http://localhost:3000/files/shumai/cat.png'
expect(resolveAssetUrl(raw, 'http://localhost:3000')).toBe(raw)
})
it('preserves remote cloud storage presigned URLs without rewriting host', () => {
const r2Url =
'https://04e37a3c563610bccea6a3ce6f8618ca.r2.cloudflarestorage.com/shumai/files/01KYKNT8NEJ3Q1G6A6K08M2XHC/Float%2002-480p.jpeg?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Signature=8112ab30'
const endpoint = 'https://staging.shumai.one'
expect(resolveAssetUrl(r2Url, endpoint)).toBe(r2Url)
})
})
describe('normalizeEndpoint', () => {
it('handles empty and null values', () => {
expect(normalizeEndpoint('')).toBe('')
expect(normalizeEndpoint(null)).toBe('')
expect(normalizeEndpoint(undefined)).toBe('')
})
it('trims whitespace and trailing slashes and converts to lower case', () => {
expect(normalizeEndpoint(' https://STAGING.shumai.one/// ')).toBe('https://staging.shumai.one')
expect(normalizeEndpoint('http://localhost:3000/')).toBe('http://localhost:3000')
})
})
describe('isSameEndpoint', () => {
it('returns true when endpoints match ignoring slashes and casing', () => {
expect(isSameEndpoint('https://staging.shumai.one/', 'https://STAGING.shumai.one')).toBe(true)
expect(isSameEndpoint('http://localhost:3000', 'http://localhost:3000/')).toBe(true)
})
it('returns false when endpoints differ', () => {
expect(isSameEndpoint('http://localhost:3000', 'https://staging.shumai.one')).toBe(false)
expect(isSameEndpoint('http://localhost:3000', 'http://127.0.0.1:3000')).toBe(false)
expect(isSameEndpoint('', 'http://localhost:3000')).toBe(false)
expect(isSameEndpoint(null, undefined)).toBe(false)
})
})
+43
View File
@@ -0,0 +1,43 @@
/**
* Utility functions for URL manipulation and resolution in UXP plugins.
*/
/**
* Resolves an asset URL (such as a thumbnail or file download) against
* the user-configured Shumai endpoint.
*
* Handles:
* - Relative paths (/files/..., /api/...) by prepending the endpoint.
* - Absolute URLs (http://, https://) are preserved as-is.
*/
export function resolveAssetUrl(url?: string | null, endpoint?: string): string | undefined {
if (!url) return undefined
if (!endpoint) return url
const cleanEndpoint = endpoint.replace(/\/+$/, '')
// Handle relative URLs (e.g. /files/..., /api/...)
if (url.startsWith('/') && !url.startsWith('//')) {
return `${cleanEndpoint}${url}`
}
return url
}
/**
* Normalizes an endpoint URL by trimming whitespace, stripping trailing slashes,
* and converting to lower case for reliable comparison.
*/
export function normalizeEndpoint(endpoint?: string | null): string {
if (!endpoint) return ''
return endpoint.trim().replace(/\/+$/, '').toLowerCase()
}
/**
* Checks if two endpoints refer to the same server URL.
*/
export function isSameEndpoint(ep1?: string | null, ep2?: string | null): boolean {
const n1 = normalizeEndpoint(ep1)
const n2 = normalizeEndpoint(ep2)
return Boolean(n1 && n2 && n1 === n2)
}
+169
View File
@@ -0,0 +1,169 @@
import React, { useState } from 'react'
import { getShumaiClient } from '../api/client'
import { saveStoredCredentials } from '../services/storage'
import { Button } from '@swc-react/button'
import { Textfield } from '@swc-react/textfield'
import { FieldLabel } from '@swc-react/field-label'
import { HelpText } from '@swc-react/help-text'
import { ProgressCircle } from '@swc-react/progress-circle'
interface AuthViewProps {
initialEndpoint?: string
initialApiKey?: string
onConnectSuccess: (endpoint: string, apiKey: string) => void
}
export const AuthView: React.FC<AuthViewProps> = ({
initialEndpoint = 'http://localhost:3000',
initialApiKey = '',
onConnectSuccess,
}) => {
const [endpoint, setEndpoint] = useState(initialEndpoint)
const [apiKey, setApiKey] = useState(initialApiKey)
const [loading, setLoading] = useState(false)
const [errorMessage, setErrorMessage] = useState<string | null>(null)
const handleConnect = async (e?: React.SyntheticEvent) => {
if (e) {
e.preventDefault()
}
setErrorMessage(null)
const trimmedEndpoint = endpoint.trim().replace(/\/+$/, '')
const trimmedKey = apiKey.trim()
if (!trimmedEndpoint) {
setErrorMessage('Please enter your Shumai server endpoint.')
return
}
if (!trimmedKey) {
setErrorMessage('Please enter your Shumai API key.')
return
}
try {
new URL(trimmedEndpoint)
} catch {
setErrorMessage(
'Invalid endpoint URL. Example: http://localhost:3000 or https://shumai.example.com',
)
return
}
setLoading(true)
console.log('[Shumai UXP] Connecting to:', trimmedEndpoint)
try {
const client = getShumaiClient(trimmedEndpoint, trimmedKey)
const res = await client.api.projects.$get({
query: { first: '1' },
})
console.log('[Shumai UXP] Response status:', res.status)
if (res.status === 401) {
setErrorMessage('Unauthorized: Invalid API Key. Please verify your token.')
setLoading(false)
return
}
if (!res.ok) {
const errorData = (await res.json().catch(() => ({}))) as { error?: string }
setErrorMessage(errorData.error || `Connection failed with status ${res.status}`)
setLoading(false)
return
}
// Validated successfully
saveStoredCredentials(trimmedEndpoint, trimmedKey)
onConnectSuccess(trimmedEndpoint, trimmedKey)
} catch (err) {
console.error('[Shumai UXP] Failed to connect to Shumai server:', err)
setErrorMessage(
err instanceof Error
? `Cannot reach server: ${err.message}`
: 'Could not connect to the Shumai server. Please check the URL and your network connection.',
)
} finally {
setLoading(false)
}
}
const handleKeyDown = (e: React.KeyboardEvent) => {
if (e.key === 'Enter') {
e.preventDefault()
handleConnect(e)
}
}
return (
<div className="view-content" style={{ justifyContent: 'center' }}>
<div className="auth-container">
<div className="auth-header">
<h2>Connect to Shumai</h2>
<p>Enter your server URL and API key to integrate Premiere Pro with your workspace.</p>
</div>
{errorMessage && (
<div style={{ marginBottom: '12px' }}>
<HelpText variant="negative" icon>
{errorMessage}
</HelpText>
</div>
)}
<div className="auth-form">
<div className="form-group">
<FieldLabel for="endpoint-input">Server Endpoint</FieldLabel>
<Textfield
id="endpoint-input"
style={{ width: '100%' }}
placeholder="https://shumai.example.com"
value={endpoint}
onInput={(e: React.FormEvent<HTMLElement>) =>
setEndpoint((e.target as HTMLInputElement).value)
}
onKeyDown={handleKeyDown}
disabled={loading}
invalid={Boolean(errorMessage && !endpoint.trim())}
/>
<HelpText>The base URL of your Shumai backend instance.</HelpText>
</div>
<div className="form-group">
<FieldLabel for="api-key-input">API Key</FieldLabel>
<Textfield
id="api-key-input"
type="password"
style={{ width: '100%' }}
placeholder="Paste your API key here"
value={apiKey}
onInput={(e: React.FormEvent<HTMLElement>) =>
setApiKey((e.target as HTMLInputElement).value)
}
onKeyDown={handleKeyDown}
disabled={loading}
invalid={Boolean(errorMessage && !apiKey.trim())}
/>
<HelpText>Generate an API key in Shumai: Settings &gt; Developer.</HelpText>
</div>
<Button
variant="accent"
onClick={handleConnect}
style={{ width: '100%', marginTop: '8px' }}
disabled={loading}
>
{loading ? 'Connecting...' : 'Connect Workspace'}
{loading ? (
<ProgressCircle indeterminate size="s" static-color="white" slot="icon" />
) : (
<sp-icon-arrow-right size="s" slot="icon"></sp-icon-arrow-right>
)}
</Button>
</div>
</div>
</div>
)
}
@@ -0,0 +1,790 @@
import React, { useEffect, useState, useCallback } from 'react'
import { getShumaiClient } from '../api/client'
import { Breadcrumb, BreadcrumbCrumb } from '../components/Breadcrumb'
import { FileCardItem, AssetSummary } from '../components/FileItem'
import { ImportVideoDialog } from '../components/ImportVideoDialog'
import { LinkSequenceDialog } from '../components/LinkSequenceDialog'
import {
getAllSequenceLinksFromCache,
getAllLinkedSequences,
normalizeGuid,
removeSequenceLink,
removeSequenceLinkFromCache,
} from '../services/linkStorage'
import { getActiveProject, getAllSequences } from '../services/premiere'
import type { LinkedSequenceAsset } from '../types/link'
import { importAssetIntoPremiere, type ProxyOption } from '../services/import'
import { ProjectSummary } from './ProjectsView'
import { isSameEndpoint } from '../utils/url'
import { ActionButton } from '@swc-react/action-button'
import { Button } from '@swc-react/button'
import { Search } from '@swc-react/search'
import { ProgressCircle } from '@swc-react/progress-circle'
import { StatusLight } from '@swc-react/status-light'
import { IllustratedMessage } from '@swc-react/illustrated-message'
import { Divider } from '@swc-react/divider'
import type { SearchCondition, SearchSort } from '@shumai/dtos'
const PAGE_SIZE = 20
interface FileListViewProps {
endpoint: string
apiKey: string
project: ProjectSummary
onBackToProjects: () => void
onLinkCountChange?: (count: number) => void
}
export const FileListView: React.FC<FileListViewProps> = ({
endpoint,
apiKey,
project,
onBackToProjects,
onLinkCountChange,
}) => {
const [currentFolderId, setCurrentFolderId] = useState<string | null>(project.rootFolder || null)
const [crumbs, setCrumbs] = useState<BreadcrumbCrumb[]>([])
// Folders state
const [folders, setFolders] = useState<AssetSummary[]>([])
const [foldersTotal, setFoldersTotal] = useState<number | null>(null)
const [foldersCursor, setFoldersCursor] = useState<string | null>(null)
const [foldersHasNext, setFoldersHasNext] = useState(false)
const [foldersExpanded, setFoldersExpanded] = useState(true)
const [loadingMoreFolders, setLoadingMoreFolders] = useState(false)
// Files state
const [files, setFiles] = useState<AssetSummary[]>([])
const [filesTotal, setFilesTotal] = useState<number | null>(null)
const [filesCursor, setFilesCursor] = useState<string | null>(null)
const [filesHasNext, setFilesHasNext] = useState(false)
const [filesExpanded, setFilesExpanded] = useState(true)
const [loadingMoreFiles, setLoadingMoreFiles] = useState(false)
const [loading, setLoading] = useState(true)
const [error, setError] = useState<string | null>(null)
const [searchTerm, setSearchTerm] = useState('')
const [debouncedSearch, setDebouncedSearch] = useState('')
const [videoForDialog, setVideoForDialog] = useState<AssetSummary | null>(null)
const [assetForLinkDialog, setAssetForLinkDialog] = useState<AssetSummary | null>(null)
const [linkedAssetsMap, setLinkedAssetsMap] = useState<Record<string, LinkedSequenceAsset>>({})
// Refresh links from cache and active Premiere project
const refreshLinkedAssets = useCallback(async () => {
// 1. Immediately read from cache (fast, non-blocking)
const cachedLinks = getAllSequenceLinksFromCache()
if (cachedLinks.length > 0) {
const map: Record<string, LinkedSequenceAsset> = {}
for (const link of cachedLinks) {
if (!link.endpoint || isSameEndpoint(link.endpoint, endpoint)) {
map[link.assetId] = link
}
}
setLinkedAssetsMap((prev) => ({ ...prev, ...map }))
onLinkCountChange?.(Object.keys(map).length)
}
// 2. Query active project in Premiere Pro for live persistent links
try {
const pr = await getActiveProject()
if (pr) {
const liveLinks = await getAllLinkedSequences(pr)
const liveMap: Record<string, LinkedSequenceAsset> = {}
for (const link of liveLinks) {
if (!link.endpoint || isSameEndpoint(link.endpoint, endpoint)) {
liveMap[link.assetId] = link
}
}
setLinkedAssetsMap(liveMap)
onLinkCountChange?.(Object.keys(liveMap).length)
}
} catch (err) {
console.warn('[FileListView] Could not get linked sequences from active project:', err)
}
}, [endpoint, onLinkCountChange])
useEffect(() => {
void refreshLinkedAssets()
}, [refreshLinkedAssets])
const handleUnlinkAsset = useCallback(
async (asset: AssetSummary) => {
const link = linkedAssetsMap[asset.id]
if (!link) return
// Optimistically remove from state immediately
setLinkedAssetsMap((prev) => {
const copy = { ...prev }
delete copy[asset.id]
return copy
})
try {
const pr = await getActiveProject()
if (pr) {
const allSeqs = await getAllSequences(pr)
const targetSeq = allSeqs.find(
(s) => normalizeGuid(s.guid) === normalizeGuid(link.sequenceGuid),
)
if (targetSeq) {
await removeSequenceLink(pr, targetSeq)
} else {
removeSequenceLinkFromCache(link.sequenceGuid, pr.guid ? pr.guid.toString() : null)
}
} else {
removeSequenceLinkFromCache(link.sequenceGuid)
}
void refreshLinkedAssets()
setImportStatus({
id: Date.now().toString(),
fileName: asset.name,
status: 'success',
message: `Unlinked from "${link.sequenceName}".`,
})
setTimeout(() => {
setImportStatus((prev) => (prev?.fileName === asset.name ? null : prev))
}, 3000)
} catch (err) {
console.error('Failed to unlink asset:', err)
void refreshLinkedAssets()
setImportStatus({
id: Date.now().toString(),
fileName: asset.name,
status: 'error',
message: 'Failed to unlink sequence.',
})
setTimeout(() => {
setImportStatus((prev) => (prev?.fileName === asset.name ? null : prev))
}, 4000)
}
},
[linkedAssetsMap, refreshLinkedAssets],
)
// Import task state
const [importStatus, setImportStatus] = useState<{
id: string
fileName: string
status: 'importing' | 'success' | 'error'
message: string
} | null>(null)
const runImport = async (asset: AssetSummary, type: 'raw' | 'proxy', proxyItem?: ProxyOption) => {
const taskId = Date.now().toString()
const label = type === 'raw' ? asset.name : `${asset.name} (${proxyItem?.label || 'Proxy'})`
setImportStatus({
id: taskId,
fileName: label,
status: 'importing',
message: 'Starting import...',
})
try {
const result = await importAssetIntoPremiere({
endpoint,
apiKey,
asset,
type,
proxyItem,
onProgress: (msg) => {
setImportStatus((prev) => (prev?.id === taskId ? { ...prev, message: msg } : prev))
},
})
if (result.cancelled) {
setImportStatus(null)
return
}
if (result.success) {
setImportStatus({
id: taskId,
fileName: result.fileName || label,
status: 'success',
message: result.message,
})
setTimeout(() => {
setImportStatus((prev) => (prev?.id === taskId ? null : prev))
}, 4000)
} else {
setImportStatus({
id: taskId,
fileName: label,
status: 'error',
message: result.message,
})
setTimeout(() => {
setImportStatus((prev) => (prev?.id === taskId ? null : prev))
}, 6000)
}
} catch (err) {
setImportStatus({
id: taskId,
fileName: label,
status: 'error',
message: err instanceof Error ? err.message : 'Import failed.',
})
setTimeout(() => {
setImportStatus((prev) => (prev?.id === taskId ? null : prev))
}, 6000)
}
}
const handleImportRaw = (asset: AssetSummary) => {
runImport(asset, 'raw')
}
const handleImportProxy = (asset: AssetSummary, proxy: ProxyOption) => {
runImport(asset, 'proxy', proxy)
}
// Debounce search term by 300ms
useEffect(() => {
const timer = setTimeout(() => {
setDebouncedSearch(searchTerm.trim())
}, 300)
return () => clearTimeout(timer)
}, [searchTerm])
// Initial fetch of both folders and files
const fetchContents = useCallback(
async (folderId: string, query: string) => {
setLoading(true)
setError(null)
try {
const client = getShumaiClient(endpoint, apiKey)
const isSearching = Boolean(query)
const conditions: SearchCondition[] = isSearching
? [{ field: 'name', operator: 'contains', value: query }]
: []
const sort: SearchSort = { field: 'name', order: 'asc' }
// Fetch first page of folders and files in parallel
const [foldersRes, filesRes] = await Promise.all([
client.api.folders[':folderId'].search.$post({
param: { folderId },
json: {
assetType: 'folder',
recursively: isSearching,
conditions,
sort,
first: PAGE_SIZE,
previewFormat: 'jpeg',
},
}),
client.api.folders[':folderId'].search.$post({
param: { folderId },
json: {
assetType: 'file',
recursively: isSearching,
conditions,
sort,
first: PAGE_SIZE,
previewFormat: 'jpeg',
},
}),
])
if (!foldersRes.ok) {
const errData = (await foldersRes.json().catch(() => ({}))) as { error?: string }
throw new Error(errData.error || `Failed to search folders (${foldersRes.status})`)
}
if (!filesRes.ok) {
const errData = (await filesRes.json().catch(() => ({}))) as { error?: string }
throw new Error(errData.error || `Failed to search files (${filesRes.status})`)
}
const foldersBody = await foldersRes.json()
const filesBody = await filesRes.json()
const folderItems = (foldersBody.data || []) as AssetSummary[]
const fileItems = (filesBody.data || []) as AssetSummary[]
setFolders(folderItems)
setFoldersCursor(foldersBody.pageInfo?.cursor || null)
setFoldersHasNext(Boolean(foldersBody.pageInfo?.cursor))
setFoldersTotal(foldersBody.pageInfo?.total ?? folderItems.length)
setFiles(fileItems)
setFilesCursor(filesBody.pageInfo?.cursor || null)
setFilesHasNext(Boolean(filesBody.pageInfo?.cursor))
setFilesTotal(filesBody.pageInfo?.total ?? fileItems.length)
} catch (err) {
console.error('Error fetching folder contents via search API:', err)
setError(err instanceof Error ? err.message : 'Failed to load folder contents.')
} finally {
setLoading(false)
}
},
[endpoint, apiKey],
)
useEffect(() => {
if (currentFolderId) {
fetchContents(currentFolderId, debouncedSearch)
} else {
setError('Root folder ID not available for this project.')
setLoading(false)
}
}, [currentFolderId, debouncedSearch, fetchContents])
// Paginate next files
const fetchNextFilesPage = useCallback(async () => {
if (!currentFolderId || !filesHasNext || loadingMoreFiles || loading) return
setLoadingMoreFiles(true)
try {
const client = getShumaiClient(endpoint, apiKey)
const isSearching = Boolean(debouncedSearch)
const conditions: SearchCondition[] = isSearching
? [{ field: 'name', operator: 'contains', value: debouncedSearch }]
: []
const sort: SearchSort = { field: 'name', order: 'asc' }
const res = await client.api.folders[':folderId'].search.$post({
param: { folderId: currentFolderId },
json: {
assetType: 'file',
recursively: isSearching,
conditions,
sort,
first: PAGE_SIZE,
after: filesCursor || undefined,
previewFormat: 'jpeg',
},
})
if (res.ok) {
const body = await res.json()
const newFiles = (body.data || []) as AssetSummary[]
setFiles((prev) => [...prev, ...newFiles])
setFilesCursor(body.pageInfo?.cursor || null)
setFilesHasNext(Boolean(body.pageInfo?.cursor))
if (body.pageInfo?.total != null) {
setFilesTotal(body.pageInfo.total)
}
}
} catch (err) {
console.error('Error fetching next files page:', err)
} finally {
setLoadingMoreFiles(false)
}
}, [
currentFolderId,
filesHasNext,
loadingMoreFiles,
loading,
endpoint,
apiKey,
debouncedSearch,
filesCursor,
])
// Paginate next folders
const fetchNextFoldersPage = useCallback(async () => {
if (!currentFolderId || !foldersHasNext || loadingMoreFolders || loading) return
setLoadingMoreFolders(true)
try {
const client = getShumaiClient(endpoint, apiKey)
const isSearching = Boolean(debouncedSearch)
const conditions: SearchCondition[] = isSearching
? [{ field: 'name', operator: 'contains', value: debouncedSearch }]
: []
const sort: SearchSort = { field: 'name', order: 'asc' }
const res = await client.api.folders[':folderId'].search.$post({
param: { folderId: currentFolderId },
json: {
assetType: 'folder',
recursively: isSearching,
conditions,
sort,
first: PAGE_SIZE,
after: foldersCursor || undefined,
previewFormat: 'jpeg',
},
})
if (res.ok) {
const body = await res.json()
const newFolders = (body.data || []) as AssetSummary[]
setFolders((prev) => [...prev, ...newFolders])
setFoldersCursor(body.pageInfo?.cursor || null)
setFoldersHasNext(Boolean(body.pageInfo?.cursor))
if (body.pageInfo?.total != null) {
setFoldersTotal(body.pageInfo.total)
}
}
} catch (err) {
console.error('Error fetching next folders page:', err)
} finally {
setLoadingMoreFolders(false)
}
}, [
currentFolderId,
foldersHasNext,
loadingMoreFolders,
loading,
endpoint,
apiKey,
debouncedSearch,
foldersCursor,
])
// Infinite scroll listener
const handleScroll = (e: React.UIEvent<HTMLDivElement>) => {
const target = e.currentTarget
const threshold = 120
const isNearBottom = target.scrollHeight - target.scrollTop - target.clientHeight <= threshold
if (isNearBottom) {
if (filesExpanded && filesHasNext && !loadingMoreFiles) {
fetchNextFilesPage()
} else if (
foldersExpanded &&
foldersHasNext &&
!loadingMoreFolders &&
(!filesExpanded || files.length === 0)
) {
fetchNextFoldersPage()
}
}
}
const handleFolderClick = (folder: AssetSummary) => {
setCrumbs((prev) => [...prev, { id: folder.id, name: folder.name }])
setCurrentFolderId(folder.id)
setSearchTerm('')
}
const handleCrumbNavigate = (crumbIndex: number) => {
setSearchTerm('')
if (crumbIndex === -1) {
setCrumbs([])
if (project.rootFolder) {
setCurrentFolderId(project.rootFolder)
}
} else {
const targetCrumb = crumbs[crumbIndex]
setCrumbs((prev) => prev.slice(0, crumbIndex + 1))
setCurrentFolderId(targetCrumb.id)
}
}
return (
<div
style={{
display: 'flex',
flexDirection: 'column',
flex: 1,
minHeight: 0,
overflow: 'hidden',
}}
>
<Breadcrumb
projectName={project.name}
crumbs={crumbs}
onNavigateToProjects={onBackToProjects}
onNavigateToCrumb={handleCrumbNavigate}
/>
{/* Sticky Header: Search input & Refresh button */}
<div className="view-sticky-header">
<div
style={{
display: 'flex',
alignItems: 'center',
gap: '8px',
marginBottom: '8px',
}}
>
<div style={{ flex: 1 }}>
<Search
style={{ width: '100%' }}
placeholder="Search files and folders..."
value={searchTerm}
onInput={(e: React.FormEvent<HTMLElement>) =>
setSearchTerm((e.target as HTMLInputElement).value)
}
/>
</div>
<sp-button
quiet
variant="secondary"
size="s"
label="Refresh folder"
icon-only
onClick={() => {
if (currentFolderId) {
fetchContents(currentFolderId, debouncedSearch)
void refreshLinkedAssets()
}
}}
title="Refresh folder"
disabled={loading || !currentFolderId}
>
<sp-icon-refresh
slot="icon"
size="s"
className={loading ? 'spin' : ''}
></sp-icon-refresh>
</sp-button>
</div>
<Divider size="s" />
</div>
<div className="view-content" onScroll={handleScroll}>
{loading && (
<div className="state-container">
<ProgressCircle indeterminate size="m" label="Loading folder contents..." />
<p style={{ marginTop: '8px' }}>Loading folder contents...</p>
</div>
)}
{error && !loading && (
<div className="state-container">
<IllustratedMessage heading="Error loading folder" description={error}>
<sp-icon-alert-circle
size="xxl"
style={{ color: 'var(--accent-red)' }}
></sp-icon-alert-circle>
</IllustratedMessage>
{currentFolderId && (
<Button
variant="secondary"
onClick={() => fetchContents(currentFolderId, debouncedSearch)}
style={{ marginTop: '12px' }}
>
Try Again
</Button>
)}
</div>
)}
{!loading && !error && folders.length === 0 && files.length === 0 && (
<div className="state-container">
<IllustratedMessage
heading={searchTerm ? 'No matching items' : 'Folder is empty'}
description={
searchTerm
? `No files or subfolders match "${searchTerm}".`
: 'No files or subfolders found in this directory.'
}
>
<sp-icon-folder-open size="xxl" style={{ color: '#999999' }}></sp-icon-folder-open>
</IllustratedMessage>
</div>
)}
{!loading && !error && (folders.length > 0 || files.length > 0) && (
<>
{/* Folders Section */}
{folders.length > 0 && (
<div className="section-container">
<div
className="section-header"
onClick={() => setFoldersExpanded(!foldersExpanded)}
role="button"
tabIndex={0}
title={foldersExpanded ? 'Collapse Folders' : 'Expand Folders'}
onKeyDown={(e) => {
if (e.key === 'Enter' || e.key === ' ') {
e.preventDefault()
setFoldersExpanded(!foldersExpanded)
}
}}
>
<div className="section-header-left">
<sp-button
quiet
variant="secondary"
size="xs"
label={foldersExpanded ? 'Collapse Folders' : 'Expand Folders'}
icon-only
onClick={(e: React.MouseEvent) => {
e.stopPropagation()
setFoldersExpanded(!foldersExpanded)
}}
>
{foldersExpanded ? (
<sp-icon-chevron-down slot="icon" size="xs"></sp-icon-chevron-down>
) : (
<sp-icon-chevron-right slot="icon" size="xs"></sp-icon-chevron-right>
)}
</sp-button>
<span className="section-title">Folders</span>
<span className="count-badge">{foldersTotal ?? folders.length}</span>
</div>
</div>
{foldersExpanded && (
<>
<div className="file-card-list">
{folders.map((folder) => (
<FileCardItem
key={folder.id}
asset={folder}
endpoint={endpoint}
onClick={() => handleFolderClick(folder)}
/>
))}
</div>
{foldersHasNext && (
<div style={{ display: 'flex', justifyContent: 'center', padding: '6px 0' }}>
{loadingMoreFolders ? (
<ProgressCircle indeterminate size="s" label="Loading more folders..." />
) : (
<ActionButton quiet size="s" onClick={fetchNextFoldersPage}>
Load more folders
</ActionButton>
)}
</div>
)}
</>
)}
</div>
)}
{/* Files Section */}
{files.length > 0 && (
<div
className="section-container"
style={{ marginTop: folders.length > 0 && foldersExpanded ? '14px' : '4px' }}
>
<div
className="section-header"
onClick={() => setFilesExpanded(!filesExpanded)}
role="button"
tabIndex={0}
title={filesExpanded ? 'Collapse Files' : 'Expand Files'}
onKeyDown={(e) => {
if (e.key === 'Enter' || e.key === ' ') {
e.preventDefault()
setFilesExpanded(!filesExpanded)
}
}}
>
<div className="section-header-left">
<sp-button
quiet
variant="secondary"
size="xs"
label={filesExpanded ? 'Collapse Files' : 'Expand Files'}
icon-only
onClick={(e: React.MouseEvent) => {
e.stopPropagation()
setFilesExpanded(!filesExpanded)
}}
>
{filesExpanded ? (
<sp-icon-chevron-down slot="icon" size="xs"></sp-icon-chevron-down>
) : (
<sp-icon-chevron-right slot="icon" size="xs"></sp-icon-chevron-right>
)}
</sp-button>
<span className="section-title">Files</span>
<span className="count-badge">{filesTotal ?? files.length}</span>
</div>
</div>
{filesExpanded && (
<>
<div className="file-card-list">
{files.map((file) => (
<FileCardItem
key={file.id}
asset={file}
endpoint={endpoint}
apiKey={apiKey}
onClick={() => {}}
onImportRaw={handleImportRaw}
onSelectVideoForImport={setVideoForDialog}
onLinkSequence={setAssetForLinkDialog}
onUnlinkSequence={handleUnlinkAsset}
isLinked={Boolean(linkedAssetsMap[file.id])}
linkedSequenceName={linkedAssetsMap[file.id]?.sequenceName}
/>
))}
</div>
{loadingMoreFiles && (
<div style={{ display: 'flex', justifyContent: 'center', padding: '10px 0' }}>
<ProgressCircle indeterminate size="s" label="Loading more files..." />
</div>
)}
{filesHasNext && !loadingMoreFiles && (
<div style={{ display: 'flex', justifyContent: 'center', padding: '6px 0' }}>
<ActionButton quiet size="s" onClick={fetchNextFilesPage}>
Load more files
</ActionButton>
</div>
)}
</>
)}
</div>
)}
</>
)}
</div>
{/* Video Import Modal Dialog */}
<ImportVideoDialog
asset={videoForDialog}
endpoint={endpoint}
apiKey={apiKey}
isOpen={videoForDialog != null}
onClose={() => setVideoForDialog(null)}
onImportRaw={handleImportRaw}
onImportProxy={handleImportProxy}
/>
{/* Sequence Linking Modal Dialog */}
<LinkSequenceDialog
asset={assetForLinkDialog}
endpoint={endpoint}
apiKey={apiKey}
isOpen={assetForLinkDialog != null}
onClose={() => setAssetForLinkDialog(null)}
onLinkSuccess={(newLink, addedCount) => {
setLinkedAssetsMap((prev) => ({
...prev,
[newLink.assetId]: newLink,
}))
void refreshLinkedAssets()
setImportStatus({
id: Date.now().toString(),
fileName: newLink.assetName,
status: 'success',
message: `Linked to "${newLink.sequenceName}". Synced ${addedCount} comment ${addedCount === 1 ? 'marker' : 'markers'}.`,
})
}}
/>
{/* Toast Notification for Import Progress & Status */}
{importStatus && (
<div className={`shumai-import-toast ${importStatus.status}`}>
<div className="shumai-toast-left">
{importStatus.status === 'importing' && (
<ProgressCircle indeterminate size="s" label="Importing..." />
)}
{importStatus.status === 'success' && <StatusLight variant="positive"></StatusLight>}
{importStatus.status === 'error' && <StatusLight variant="negative"></StatusLight>}
<div className="shumai-toast-text">
<span className="shumai-toast-title">{importStatus.fileName}</span>
<span className="shumai-toast-msg">{importStatus.message}</span>
</div>
</div>
<sp-action-button
quiet
size="xs"
onClick={() => setImportStatus(null)}
title="Dismiss notification"
>
×
</sp-action-button>
</div>
)}
</div>
)
}
@@ -0,0 +1,154 @@
import React, { useEffect, useState } from 'react'
import { getShumaiClient } from '../api/client'
import { ProjectCard } from '../components/ProjectCard'
import { Button } from '@swc-react/button'
import { ProgressCircle } from '@swc-react/progress-circle'
import { IllustratedMessage } from '@swc-react/illustrated-message'
import { Divider } from '@swc-react/divider'
export interface ProjectSummary {
id: string
name: string
teamId: string
rootFolder?: string | null
coverImage?: string | null
updatedAt?: string | Date
}
interface ProjectsViewProps {
endpoint: string
apiKey: string
onSelectProject: (project: ProjectSummary) => void
}
export const ProjectsView: React.FC<ProjectsViewProps> = ({
endpoint,
apiKey,
onSelectProject,
}) => {
const [projects, setProjects] = useState<ProjectSummary[]>([])
const [loading, setLoading] = useState(true)
const [error, setError] = useState<string | null>(null)
const fetchProjects = async () => {
setLoading(true)
setError(null)
try {
const client = getShumaiClient(endpoint, apiKey)
const res = await client.api.projects.$get({
query: { first: '200', previewFormat: 'jpeg' },
})
if (!res.ok) {
const errData = (await res.json().catch(() => ({}))) as { error?: string }
throw new Error(errData.error || `Failed to fetch projects (${res.status})`)
}
const body = await res.json()
setProjects((body.data || []) as ProjectSummary[])
} catch (err) {
console.error('Error fetching projects:', err)
setError(err instanceof Error ? err.message : 'Failed to load projects.')
} finally {
setLoading(false)
}
}
useEffect(() => {
fetchProjects()
}, [endpoint, apiKey])
return (
<div
style={{
display: 'flex',
flexDirection: 'column',
flex: 1,
minHeight: 0,
overflow: 'hidden',
}}
>
{/* Sticky Title Bar */}
<div className="view-sticky-header">
<div
style={{
display: 'flex',
alignItems: 'center',
justifyContent: 'space-between',
marginBottom: '8px',
}}
>
<div style={{ display: 'flex', alignItems: 'center', gap: '6px' }}>
<h2 style={{ fontSize: '13px', fontWeight: 600 }}>Projects</h2>
{!loading && <span className="count-badge">{projects.length}</span>}
</div>
<sp-button
quiet
variant="secondary"
size="s"
label="Refresh projects"
icon-only
onClick={fetchProjects}
title="Refresh projects"
disabled={loading}
>
<sp-icon-refresh
slot="icon"
size="s"
className={loading ? 'spin' : ''}
></sp-icon-refresh>
</sp-button>
</div>
<Divider size="s" />
</div>
<div className="view-content">
{loading && (
<div className="state-container">
<ProgressCircle indeterminate size="m" label="Loading projects..." />
<p style={{ marginTop: '8px' }}>Loading projects...</p>
</div>
)}
{error && !loading && (
<div className="state-container">
<IllustratedMessage heading="Error loading projects" description={error}>
<sp-icon-alert-circle
size="xxl"
style={{ color: 'var(--accent-red)' }}
></sp-icon-alert-circle>
</IllustratedMessage>
<Button variant="secondary" onClick={fetchProjects} style={{ marginTop: '12px' }}>
Try Again
</Button>
</div>
)}
{!loading && !error && projects.length === 0 && (
<div className="state-container">
<IllustratedMessage
heading="No projects found"
description="Create a project in your Shumai workspace to get started."
>
<sp-icon-briefcase size="xxl" style={{ color: '#999999' }}></sp-icon-briefcase>
</IllustratedMessage>
</div>
)}
{!loading && !error && projects.length > 0 && (
<div className="project-card-list">
{projects.map((project) => (
<ProjectCard
key={project.id}
project={project}
endpoint={endpoint}
onClick={() => onSelectProject(project)}
/>
))}
</div>
)}
</div>
</div>
)
}
@@ -0,0 +1,253 @@
// @vitest-environment happy-dom
import React, { act } from 'react'
import { describe, it, expect, vi, afterEach, beforeEach } from 'vitest'
import { render, screen, fireEvent, cleanup } from '@testing-library/react'
import { SequencesView } from './SequencesView'
import type { Project, Sequence } from '@adobe/premierepro'
import * as premiereService from '../services/premiere'
import * as linkStorage from '../services/linkStorage'
import * as markersService from '../services/markers'
import type { CommentInfo } from '@shumai/dtos'
// Configure React 19 act environment for happy-dom
;(globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true
describe('SequencesView Component', () => {
const mockOnLinkCountChange = vi.fn()
beforeEach(() => {
vi.restoreAllMocks()
})
afterEach(() => {
cleanup()
})
it('renders unified empty state when no sequences are linked', async () => {
const mockSeq = { guid: 'seq-1', name: 'Sequence 01' }
const mockProject = { guid: 'proj-1' }
vi.spyOn(premiereService, 'getActiveProject').mockResolvedValue(
mockProject as unknown as Project,
)
vi.spyOn(premiereService, 'getActiveSequence').mockResolvedValue(mockSeq as unknown as Sequence)
vi.spyOn(premiereService, 'getAllSequences').mockResolvedValue([mockSeq as unknown as Sequence])
vi.spyOn(linkStorage, 'getAllLinkedSequences').mockResolvedValue([])
await act(async () => {
render(
<SequencesView
endpoint="https://api.shumai.test"
apiKey="test-key"
onLinkCountChange={mockOnLinkCountChange}
/>,
)
})
expect(screen.getByText('No Linked Sequences')).toBeDefined()
expect(screen.getByText(/Sequence 01/i)).toBeDefined()
expect(screen.queryByText('Browse Assets to Link')).toBeNull()
})
it('renders linked sequence card and handles unlink', async () => {
const mockSeq = { guid: 'seq-1', name: 'Sequence 01' }
const mockProject = { guid: 'proj-1' }
const mockLink = {
sequenceGuid: 'seq-1',
sequenceName: 'Sequence 01',
assetId: 'asset-1',
assetName: 'final_edit.mp4',
syncedCommentIds: ['comm-1'],
lastSyncAt: Date.now(),
totalCommentsSynced: 1,
}
vi.spyOn(premiereService, 'getActiveProject').mockResolvedValue(
mockProject as unknown as Project,
)
vi.spyOn(premiereService, 'getActiveSequence').mockResolvedValue(mockSeq as unknown as Sequence)
vi.spyOn(premiereService, 'getAllSequences').mockResolvedValue([mockSeq as unknown as Sequence])
vi.spyOn(linkStorage, 'getAllLinkedSequences').mockResolvedValue([mockLink])
vi.spyOn(linkStorage, 'removeSequenceLink').mockResolvedValue(true)
await act(async () => {
render(
<SequencesView
endpoint="https://api.shumai.test"
apiKey="test-key"
onLinkCountChange={mockOnLinkCountChange}
/>,
)
})
expect(screen.getAllByText('Sequence 01').length).toBeGreaterThan(0)
expect(screen.getAllByText(/Asset: final_edit.mp4/i).length).toBeGreaterThan(0)
const unlinkButtons = screen.getAllByTitle('Unlink sequence')
expect(unlinkButtons.length).toBeGreaterThan(0)
await act(async () => {
fireEvent.click(unlinkButtons[0])
})
expect(linkStorage.removeSequenceLink).toHaveBeenCalledWith(mockProject, mockSeq)
})
it('filters out foreign endpoint links from the view and link count', async () => {
const mockSeq1 = { guid: 'seq-1', name: 'Sequence Foreign' }
const mockSeq2 = { guid: 'seq-2', name: 'Sequence Staging' }
const mockProject = { guid: 'proj-1' }
const foreignLink = {
sequenceGuid: 'seq-1',
sequenceName: 'Sequence Foreign',
assetId: 'asset-dev',
assetName: 'dev_asset.mp4',
endpoint: 'http://localhost:3000',
syncedCommentIds: [],
lastSyncAt: Date.now(),
totalCommentsSynced: 0,
}
const stagingLink = {
sequenceGuid: 'seq-2',
sequenceName: 'Sequence Staging',
assetId: 'asset-staging',
assetName: 'staging_asset.mp4',
endpoint: 'https://staging.shumai.one',
syncedCommentIds: [],
lastSyncAt: Date.now(),
totalCommentsSynced: 0,
}
vi.spyOn(premiereService, 'getActiveProject').mockResolvedValue(
mockProject as unknown as Project,
)
vi.spyOn(premiereService, 'getActiveSequence').mockResolvedValue(
mockSeq1 as unknown as Sequence,
)
vi.spyOn(premiereService, 'getAllSequences').mockResolvedValue([
mockSeq1 as unknown as Sequence,
mockSeq2 as unknown as Sequence,
])
vi.spyOn(linkStorage, 'getAllLinkedSequences').mockResolvedValue([foreignLink, stagingLink])
await act(async () => {
render(
<SequencesView
endpoint="https://staging.shumai.one"
apiKey="staging-key"
onLinkCountChange={mockOnLinkCountChange}
/>,
)
})
// Foreign link should be completely hidden
expect(screen.queryByText('dev_asset.mp4')).toBeNull()
expect(screen.queryByText(/Server:/i)).toBeNull()
// Matching link should be visible
expect(screen.getAllByText(/staging_asset.mp4/i).length).toBeGreaterThan(0)
// Active sequence (seq-1) is linked to foreign server, so current sequence card should show unlinked state
expect(screen.getByText('This sequence is not linked to any Shumai asset.')).toBeDefined()
// Link count reported to parent should only count staging link (1)
expect(mockOnLinkCountChange).toHaveBeenCalledWith(1)
})
it('shows error toast when manual sync fails', async () => {
const mockSeq = { guid: 'seq-1', name: 'Sequence 01' }
const mockProject = { guid: 'proj-1' }
const mockLink = {
sequenceGuid: 'seq-1',
sequenceName: 'Sequence 01',
assetId: 'asset-missing',
assetName: 'missing.mp4',
endpoint: 'https://staging.shumai.one',
syncedCommentIds: [],
lastSyncAt: Date.now(),
totalCommentsSynced: 0,
}
vi.spyOn(premiereService, 'getActiveProject').mockResolvedValue(
mockProject as unknown as Project,
)
vi.spyOn(premiereService, 'getActiveSequence').mockResolvedValue(mockSeq as unknown as Sequence)
vi.spyOn(premiereService, 'getAllSequences').mockResolvedValue([mockSeq as unknown as Sequence])
vi.spyOn(linkStorage, 'getAllLinkedSequences').mockResolvedValue([mockLink])
vi.spyOn(markersService, 'fetchAssetComments').mockRejectedValue(
new Error('Asset not found on this server (HTTP 404)'),
)
await act(async () => {
render(
<SequencesView
endpoint="https://staging.shumai.one"
apiKey="staging-key"
onLinkCountChange={mockOnLinkCountChange}
/>,
)
})
const syncButtons = screen.getAllByTitle('Sync comments now')
expect(syncButtons[0].hasAttribute('disabled')).toBe(false)
await act(async () => {
fireEvent.click(syncButtons[0])
})
expect(markersService.fetchAssetComments).toHaveBeenCalledWith(
'https://staging.shumai.one',
'staging-key',
'asset-missing',
)
expect(screen.getByText('Asset not found on this server (HTTP 404)')).toBeDefined()
})
it('shows success toast when manual sync succeeds', async () => {
const mockSeq = { guid: 'seq-1', name: 'Sequence 01' }
const mockProject = { guid: 'proj-1' }
const mockLink = {
sequenceGuid: 'seq-1',
sequenceName: 'Sequence 01',
assetId: 'asset-1',
assetName: 'final.mp4',
endpoint: 'https://staging.shumai.one',
syncedCommentIds: [],
lastSyncAt: Date.now(),
totalCommentsSynced: 0,
}
vi.spyOn(premiereService, 'getActiveProject').mockResolvedValue(
mockProject as unknown as Project,
)
vi.spyOn(premiereService, 'getActiveSequence').mockResolvedValue(mockSeq as unknown as Sequence)
vi.spyOn(premiereService, 'getAllSequences').mockResolvedValue([mockSeq as unknown as Sequence])
vi.spyOn(linkStorage, 'getAllLinkedSequences').mockResolvedValue([mockLink])
vi.spyOn(markersService, 'fetchAssetComments').mockResolvedValue([
{ id: 'comm-1', second: 10, message: 'Fix color' } as unknown as CommentInfo,
])
vi.spyOn(markersService, 'syncCommentsToSequence').mockResolvedValue({
updatedLink: { ...mockLink, syncedCommentIds: ['comm-1'], totalCommentsSynced: 1 },
addedCount: 1,
})
await act(async () => {
render(
<SequencesView
endpoint="https://staging.shumai.one"
apiKey="staging-key"
onLinkCountChange={mockOnLinkCountChange}
/>,
)
})
const syncButtons = screen.getAllByTitle('Sync comments now')
await act(async () => {
fireEvent.click(syncButtons[0])
})
expect(screen.getByText('Synced 1 new comment marker for "Sequence 01".')).toBeDefined()
})
})
@@ -0,0 +1,524 @@
import React, { useState, useEffect, useCallback } from 'react'
import type { Project, Sequence } from '@adobe/premierepro'
import type { LinkedSequenceAsset } from '../types/link'
import {
getActiveProject,
getActiveSequence,
getAllSequences,
openSequenceInTimeline,
getPremiereModule,
} from '../services/premiere'
import { getAllLinkedSequences, normalizeGuid, removeSequenceLink } from '../services/linkStorage'
import { fetchAssetComments, syncCommentsToSequence } from '../services/markers'
import { resolveAssetUrl, isSameEndpoint } from '../utils/url'
import { formatDateAgo } from '../utils/date'
import { ProgressCircle } from '@swc-react/progress-circle'
export interface SequencesViewProps {
endpoint: string
apiKey: string
onLinkCountChange?: (count: number) => void
}
export const SequencesView: React.FC<SequencesViewProps> = ({
endpoint,
apiKey,
onLinkCountChange,
}) => {
const [project, setProject] = useState<Project | null>(null)
const [activeSeq, setActiveSeq] = useState<Sequence | null>(null)
const [allSeqs, setAllSeqs] = useState<Sequence[]>([])
const [linkedSequences, setLinkedSequences] = useState<LinkedSequenceAsset[]>([])
const [loading, setLoading] = useState(true)
const [syncingGuid, setSyncingGuid] = useState<string | null>(null)
const [unlinkingGuid, setUnlinkingGuid] = useState<string | null>(null)
const [toast, setToast] = useState<{ type: 'success' | 'error'; message: string } | null>(null)
const loadData = useCallback(async () => {
try {
const pr = await getActiveProject()
setProject(pr)
if (!pr) {
setActiveSeq(null)
setAllSeqs([])
setLinkedSequences([])
onLinkCountChange?.(0)
return
}
const [currentActive, seqsList] = await Promise.all([
getActiveSequence(pr),
getAllSequences(pr),
])
setActiveSeq(currentActive)
setAllSeqs(seqsList)
const allLinks = await getAllLinkedSequences(pr, seqsList)
// Hide foreign links entirely: only show sequences linked to the current endpoint
const currentServerLinks = allLinks.filter(
(link) => !link.endpoint || isSameEndpoint(link.endpoint, endpoint),
)
setLinkedSequences(currentServerLinks)
onLinkCountChange?.(currentServerLinks.length)
} catch (err) {
console.error('[SequencesView] Failed to load sequences data:', err)
} finally {
setLoading(false)
}
}, [endpoint, onLinkCountChange])
useEffect(() => {
void loadData()
// Listen for sequence activation events in Premiere Pro
const ppro = getPremiereModule()
if (ppro?.EventManager && ppro.Constants?.SequenceEvent?.ACTIVATED) {
const handleActivated = () => {
void loadData()
}
try {
ppro.EventManager.addGlobalEventListener(
ppro.Constants.SequenceEvent.ACTIVATED,
handleActivated,
true,
)
return () => {
try {
ppro.EventManager.removeGlobalEventListener(
ppro.Constants.SequenceEvent.ACTIVATED,
handleActivated,
)
} catch {
// Ignore error on unmount
}
}
} catch (err) {
console.warn('[SequencesView] Could not add SequenceEvent listener:', err)
}
}
}, [loadData])
const showToast = (type: 'success' | 'error', message: string, duration = 4000) => {
setToast({ type, message })
setTimeout(() => {
setToast((prev) => (prev?.message === message ? null : prev))
}, duration)
}
// Sync Now handler
const handleSyncNow = async (link: LinkedSequenceAsset) => {
if (!project || syncingGuid) return
if (link.endpoint && !isSameEndpoint(link.endpoint, endpoint)) {
showToast(
'error',
`Cannot sync comments: sequence was linked to "${link.endpoint}". Connect to that server to sync.`,
5000,
)
return
}
const targetSeq =
allSeqs.find((s) => normalizeGuid(s.guid) === normalizeGuid(link.sequenceGuid)) ||
(await getAllSequences(project)).find(
(s) => normalizeGuid(s.guid) === normalizeGuid(link.sequenceGuid),
)
if (!targetSeq) return
setSyncingGuid(link.sequenceGuid)
try {
const comments = await fetchAssetComments(endpoint, apiKey, link.assetId)
const { updatedLink, addedCount } = await syncCommentsToSequence(
project,
targetSeq,
comments,
link,
)
setLinkedSequences((prev) =>
prev.map((item) =>
normalizeGuid(item.sequenceGuid) === normalizeGuid(updatedLink.sequenceGuid)
? updatedLink
: item,
),
)
showToast(
'success',
addedCount > 0
? `Synced ${addedCount} new comment ${addedCount === 1 ? 'marker' : 'markers'} for "${link.sequenceName}".`
: `All comments are already synced for "${link.sequenceName}".`,
)
} catch (err) {
console.error('[SequencesView] Failed to sync comments:', err)
showToast(
'error',
err instanceof Error ? err.message : 'Failed to sync comments from server.',
5000,
)
} finally {
setSyncingGuid(null)
}
}
// Unlink handler
const handleUnlink = async (link: LinkedSequenceAsset) => {
if (!project || unlinkingGuid) return
const targetSeq =
allSeqs.find((s) => normalizeGuid(s.guid) === normalizeGuid(link.sequenceGuid)) ||
(await getAllSequences(project)).find(
(s) => normalizeGuid(s.guid) === normalizeGuid(link.sequenceGuid),
)
if (!targetSeq) return
setUnlinkingGuid(link.sequenceGuid)
try {
await removeSequenceLink(project, targetSeq)
setLinkedSequences((prev) => {
const next = prev.filter(
(item) => normalizeGuid(item.sequenceGuid) !== normalizeGuid(link.sequenceGuid),
)
onLinkCountChange?.(next.length)
return next
})
showToast('success', `Unlinked "${link.sequenceName}" from "${link.assetName}".`, 3000)
} catch (err) {
console.error('[SequencesView] Failed to unlink sequence:', err)
showToast('error', 'Failed to unlink sequence.', 4000)
} finally {
setUnlinkingGuid(null)
}
}
// Open Sequence in Timeline handler
const handleOpenSequence = async (link: LinkedSequenceAsset) => {
if (!project) return
const targetSeq =
allSeqs.find((s) => normalizeGuid(s.guid) === normalizeGuid(link.sequenceGuid)) ||
(await getAllSequences(project)).find(
(s) => normalizeGuid(s.guid) === normalizeGuid(link.sequenceGuid),
)
if (!targetSeq) return
await openSequenceInTimeline(targetSeq, project)
setActiveSeq(targetSeq)
}
const renderToast = () => {
if (!toast) return null
const isError = toast.type === 'error'
return (
<div
style={{
marginBottom: 10,
padding: '6px 10px',
borderRadius: 4,
backgroundColor: isError ? 'rgba(239, 68, 68, 0.15)' : 'rgba(59, 130, 246, 0.15)',
border: isError
? '1px solid rgba(239, 68, 68, 0.3)'
: '1px solid rgba(59, 130, 246, 0.3)',
color: isError ? '#f87171' : '#60a5fa',
fontSize: 11,
display: 'flex',
alignItems: 'center',
}}
>
{isError ? (
<sp-icon-alert-circle
size="s"
style={{ marginRight: 6, flexShrink: 0 }}
></sp-icon-alert-circle>
) : (
<sp-icon-checkmark-circle
size="s"
style={{ marginRight: 6, flexShrink: 0 }}
></sp-icon-checkmark-circle>
)}
<span>{toast.message}</span>
</div>
)
}
if (loading) {
return (
<div
className="sequences-view-container"
style={{ justifyContent: 'center', alignItems: 'center' }}
>
<ProgressCircle indeterminate size="m" label="Loading sequences..." />
</div>
)
}
const activeGuidStr = normalizeGuid(activeSeq?.guid)
const currentSequenceLink = linkedSequences.find(
(item) => normalizeGuid(item.sequenceGuid) === activeGuidStr,
)
if (linkedSequences.length === 0) {
return (
<div className="sequences-view-container sequences-empty-container">
{renderToast()}
<div className="sequence-empty-state unified-empty">
<sp-icon-movie-camera
size="xxl"
style={{ color: '#60a5fa', opacity: 0.7, marginBottom: 12 }}
></sp-icon-movie-camera>
<div className="sequence-empty-state-title" style={{ fontSize: 14, marginBottom: 6 }}>
No Linked Sequences
</div>
<div style={{ fontSize: 11, marginBottom: 8, maxWidth: 280, lineHeight: 1.4 }}>
{activeSeq
? `Active sequence "${activeSeq.name}" is not linked to any Shumai asset.`
: 'Open a sequence in Premiere Pro and link it to a Shumai asset.'}
</div>
<div
style={{
fontSize: 11,
color: 'var(--text-secondary)',
marginBottom: 0,
maxWidth: 280,
lineHeight: 1.4,
}}
>
Linking a sequence enables automatic synchronization of comments from Shumai as timeline
markers.
</div>
</div>
</div>
)
}
return (
<div className="sequences-view-container">
{/* Toast Notification */}
{renderToast()}
{/* SECTION 1: Current Sequence Asset */}
<div className="sequence-section">
<div className="sequence-section-title">Current Sequence Asset</div>
{currentSequenceLink ? (
<div className="sequence-link-card current-active">
<div className="sequence-card-row">
<div className="sequence-card-left">
<div className="sequence-card-thumb">
{currentSequenceLink.assetThumbnailUrl ? (
<img
src={resolveAssetUrl(
currentSequenceLink.assetThumbnailUrl,
currentSequenceLink.endpoint || endpoint,
)}
alt={currentSequenceLink.assetName}
/>
) : (
<sp-icon-movie-camera
size="m"
style={{ color: '#3b82f6' }}
></sp-icon-movie-camera>
)}
</div>
<div className="sequence-card-info">
<div style={{ display: 'flex', alignItems: 'center' }}>
<span className="sequence-card-title">{currentSequenceLink.sequenceName}</span>
<span
style={{
fontSize: '9px',
marginLeft: 6,
padding: '1px 4px',
borderRadius: 3,
backgroundColor: 'rgba(59, 130, 246, 0.2)',
color: '#60a5fa',
fontWeight: 600,
}}
>
Active
</span>
</div>
<span className="sequence-card-subtitle" title={currentSequenceLink.assetName}>
Asset: {currentSequenceLink.assetName}
</span>
</div>
</div>
<div className="sequence-card-actions">
<sp-action-button
quiet
size="xs"
label="Sync comments now"
title="Sync comments now"
disabled={syncingGuid === currentSequenceLink.sequenceGuid}
onClick={() => handleSyncNow(currentSequenceLink)}
>
{syncingGuid === currentSequenceLink.sequenceGuid ? (
<ProgressCircle indeterminate size="s" slot="icon" label="Syncing..." />
) : (
<sp-icon-refresh size="s" slot="icon"></sp-icon-refresh>
)}
</sp-action-button>
<sp-action-button
quiet
size="xs"
label="Unlink sequence"
title="Unlink sequence"
disabled={unlinkingGuid === currentSequenceLink.sequenceGuid}
onClick={() => handleUnlink(currentSequenceLink)}
>
{unlinkingGuid === currentSequenceLink.sequenceGuid ? (
<ProgressCircle indeterminate size="s" slot="icon" label="Unlinking..." />
) : (
<sp-icon-unlink
size="s"
slot="icon"
style={{ color: '#f87171' }}
></sp-icon-unlink>
)}
</sp-action-button>
</div>
</div>
<div className="sequence-card-footer">
<span>
{currentSequenceLink.totalCommentsSynced}{' '}
{currentSequenceLink.totalCommentsSynced === 1 ? 'comment' : 'comments'} synced
</span>
<span>Last sync: {formatDateAgo(currentSequenceLink.lastSyncAt) || 'Just now'}</span>
</div>
</div>
) : (
<div className="sequence-empty-state compact">
<sp-icon-movie-camera
size="l"
style={{ color: '#60a5fa', opacity: 0.6, marginBottom: 4 }}
></sp-icon-movie-camera>
<div className="sequence-empty-state-title">
{activeSeq ? activeSeq.name : 'No Active Sequence'}
</div>
<div style={{ fontSize: 11, color: 'var(--text-secondary)', marginBottom: 8 }}>
{activeSeq
? 'This sequence is not linked to any Shumai asset.'
: 'Open a sequence in the timeline to view its linked asset.'}
</div>
</div>
)}
</div>
{/* SECTION 2: All Sequence Assets */}
<div className="sequence-section" style={{ marginTop: 8 }}>
<div className="sequence-section-title">All Sequence Assets ({linkedSequences.length})</div>
{linkedSequences.map((link) => {
const isActive = normalizeGuid(link.sequenceGuid) === activeGuidStr
const isSyncing = syncingGuid === link.sequenceGuid
const isUnlinking = unlinkingGuid === link.sequenceGuid
return (
<div
key={link.sequenceGuid}
className={`sequence-link-card ${isActive ? 'current-active' : ''}`}
>
<div className="sequence-card-row">
<div className="sequence-card-left">
<div className="sequence-card-thumb">
{link.assetThumbnailUrl ? (
<img
src={resolveAssetUrl(link.assetThumbnailUrl, link.endpoint || endpoint)}
alt={link.assetName}
/>
) : (
<sp-icon-movie-camera
size="m"
style={{ color: '#60a5fa' }}
></sp-icon-movie-camera>
)}
</div>
<div className="sequence-card-info">
<div style={{ display: 'flex', alignItems: 'center' }}>
<span className="sequence-card-title">{link.sequenceName}</span>
{isActive && (
<span
style={{
fontSize: '9px',
marginLeft: 6,
padding: '1px 4px',
borderRadius: 3,
backgroundColor: 'rgba(59, 130, 246, 0.2)',
color: '#60a5fa',
fontWeight: 600,
}}
>
Active
</span>
)}
</div>
<span className="sequence-card-subtitle" title={link.assetName}>
Asset: {link.assetName}
</span>
</div>
</div>
<div className="sequence-card-actions">
{!isActive && (
<sp-action-button
quiet
size="xs"
label="Open sequence in timeline"
title="Open sequence in timeline"
onClick={() => handleOpenSequence(link)}
>
<sp-icon-link-out size="s" slot="icon"></sp-icon-link-out>
</sp-action-button>
)}
<sp-action-button
quiet
size="xs"
label="Sync comments now"
title="Sync comments now"
disabled={isSyncing}
onClick={() => handleSyncNow(link)}
>
{isSyncing ? (
<ProgressCircle indeterminate size="s" slot="icon" label="Syncing..." />
) : (
<sp-icon-refresh size="s" slot="icon"></sp-icon-refresh>
)}
</sp-action-button>
<sp-action-button
quiet
size="xs"
label="Unlink sequence"
title="Unlink sequence"
disabled={isUnlinking}
onClick={() => handleUnlink(link)}
>
{isUnlinking ? (
<ProgressCircle indeterminate size="s" slot="icon" label="Unlinking..." />
) : (
<sp-icon-unlink
size="s"
slot="icon"
style={{ color: '#f87171' }}
></sp-icon-unlink>
)}
</sp-action-button>
</div>
</div>
<div className="sequence-card-footer">
<span>
{link.totalCommentsSynced}{' '}
{link.totalCommentsSynced === 1 ? 'comment' : 'comments'} synced
</span>
<span>Last sync: {formatDateAgo(link.lastSyncAt) || 'Just now'}</span>
</div>
</div>
)
})}
</div>
</div>
)
}
+9
View File
@@ -0,0 +1,9 @@
{
"extends": "../../tsconfig.json",
"compilerOptions": {
"jsx": "react-jsx",
"jsxImportSource": "react",
"types": ["bun", "node", "@adobe/premierepro"]
},
"include": ["src/**/*"]
}
+1 -1
View File
@@ -1,6 +1,6 @@
{
"name": "@shumai/transcode-app",
"version": "0.3.8",
"version": "0.4.6",
"private": true,
"type": "module",
"bin": {
+4
View File
@@ -56,6 +56,8 @@ apps/web/e2e/
|---|---|
| Sign up as the first user and become the team owner | `tests/auth/signup.spec.ts` |
| Log in with existing credentials | `tests/auth/login.spec.ts` |
| Show error when accessing reset-password page without token | `tests/auth/reset-password.spec.ts` |
| Reset password with valid token and allow logging in with new password | `tests/auth/reset-password.spec.ts` |
### team
| Test | File |
@@ -63,6 +65,7 @@ apps/web/e2e/
| Owner invites a member via invite link and the invitee joins | `tests/team/invite-member.spec.ts` |
| Owner removes a member via the members dialog; the membership is deleted from the DB | `tests/team/remove-member.spec.ts` |
| Owner changes a team member role in the members dialog and permissions update | `tests/team/change-member-role.spec.ts` |
| Owner manages resource quotas in settings and resets usage from the dashboard | `tests/team/quotas-settings.spec.ts` |
### project
| Test | File |
@@ -90,6 +93,7 @@ apps/web/e2e/
| Owner saves a search result as a collection | `tests/project/save-search-collection.spec.ts` |
| Image share with watermark + download disabled: no download buttons on public list/detail pages, watermarked proxy served, download-url rejected | `tests/project/share-watermark-no-download.spec.ts` |
| Video share with watermark + download disabled: no download buttons on public list/detail pages, watermarked proxy served, download-url rejected | `tests/project/share-watermark-no-download.spec.ts` |
| Owner views a file and it appears in recents | `tests/project/recents.spec.ts` |
### file
| Test | File |
+16 -11
View File
@@ -21,19 +21,23 @@ const currentDir = path.dirname(fileURLToPath(import.meta.url))
const envPath = path.resolve(currentDir, '.env.e2e')
const fixturesDir = path.resolve(currentDir, '../../../packages/e2e/fixtures')
// Load E2E environment variables if present
if (fs.existsSync(envPath)) {
const content = fs.readFileSync(envPath, 'utf8')
content.split('\n').forEach((line) => {
const parts = line.split('=')
if (parts.length >= 2) {
const key = parts[0].trim()
const value = parts.slice(1).join('=').trim()
process.env[key] = value
}
})
function loadEnv() {
if (fs.existsSync(envPath)) {
const content = fs.readFileSync(envPath, 'utf8')
content.split('\n').forEach((line) => {
const parts = line.split('=')
if (parts.length >= 2) {
const key = parts[0].trim()
const value = parts.slice(1).join('=').trim()
process.env[key] = value
}
})
}
}
// Load E2E environment variables if present
loadEnv()
export interface OwnerFixture {
/** Page opened in a browser context logged in as the team owner. */
page: Page
@@ -104,6 +108,7 @@ export const test = base.extend<{
prisma: [
// eslint-disable-next-line no-empty-pattern
async ({}, use) => {
loadEnv()
const connectionString = process.env.DATABASE_URL
const pool = new Pool({ connectionString })
const adapter = new PrismaPg(pool)
+22 -4
View File
@@ -24,14 +24,32 @@ export async function dragCard(page: Page, source: Locator, target: Locator): Pr
await page.mouse.move(fromX, fromY)
await page.mouse.down()
// Move in several chunks so the dnd-kit sensor activates mid-drag
const dx = toX - fromX
const dy = toY - fromY
const dist = Math.hypot(dx, dy)
// Step past the 10px activation constraint to trigger drag activation
// and give the browser a brief moment for status to become 'dragging'
const activationRatio = dist > 0 ? Math.min(1, 15 / dist) : 1
await page.mouse.move(fromX + dx * activationRatio, fromY + dy * activationRatio)
await page.waitForTimeout(50)
// Move in several chunks so the intermediate dragmove handlers run
const chunks = 8
for (let i = 1; i <= chunks; i++) {
const x = fromX + ((toX - fromX) * i) / chunks
const y = fromY + ((toY - fromY) * i) / chunks
const x = fromX + (dx * i) / chunks
const y = fromY + (dy * i) / chunks
await page.mouse.move(x, y)
await page.waitForTimeout(15)
await page.waitForTimeout(20)
}
// Ensure pointer is directly over target center and allow requestAnimationFrame
// and collision microtasks to settle before triggering drop
await page.mouse.move(toX, toY)
await page.evaluate(
() => new Promise((resolve) => requestAnimationFrame(() => requestAnimationFrame(resolve))),
)
await page.waitForTimeout(100)
await page.mouse.up()
}
+7 -6
View File
@@ -7,15 +7,16 @@ interface CreateShareResponse {
}
/**
* Locates a file/folder card by its name. File names are rendered as
* `EditableText` inputs (not text nodes), so `getByText` does not match them.
* The returned locator points at the card wrapper div (right-clickable to open
* the card context menu).
* Locates a file/folder card by its name. Matches both read-only text nodes
* and active EditableText inputs. The returned locator points at the card
* wrapper div (right-clickable to open the card context menu).
*/
export function fileCard(page: Page, name: string): Locator {
return page
.locator('div.group')
.filter({ has: page.locator(`input[value="${name}"]`) })
.locator('[data-testid="file-card"]')
.filter({
has: page.locator(`input[value="${name}"]`).or(page.getByText(name, { exact: true })),
})
.first()
}
+4 -1
View File
@@ -32,4 +32,7 @@ async function start() {
await import('../src/index.ts')
}
start().catch(console.error)
start().catch((err) => {
console.error('Failed to start E2E server:', err)
process.exit(1)
})
@@ -0,0 +1,63 @@
import { expect, test } from '../../fixtures'
import { apiSignup, E2E_PASSWORD, uniqueEmail } from '../../helpers/auth'
import { loginViaUi } from '../../helpers/ui'
test('should show error when accessing reset-password page without token', async ({ page }) => {
await page.goto('/reset-password')
await expect(page.getByText('Invalid or missing reset token.')).toBeVisible()
await expect(page.getByRole('button', { name: 'Go to Login' })).toBeVisible()
})
test('should reset password with valid token and allow logging in with new password', async ({
page,
request,
prisma,
}) => {
const email = uniqueEmail('reset-pw')
const oldPassword = E2E_PASSWORD
const newPassword = 'newSecretPassword123'
// 1. Seed user
await apiSignup(request, email, oldPassword)
// 2. Request password reset via API
const resetRes = await request.post('/api/auth/request-password-reset', {
data: {
email,
redirectTo: '/reset-password',
},
})
expect(resetRes.ok()).toBe(true)
// Retrieve the generated verification token from DB
const verification = await prisma.verification.findFirst({
where: {
identifier: { startsWith: 'reset-password:' },
},
orderBy: { createdAt: 'desc' },
})
expect(verification).not.toBeNull()
const token = verification!.identifier.replace('reset-password:', '')
// 3. Open reset password page with token
await page.goto(`/reset-password?token=${token}`)
// 4. Fill in new password and confirmation
await page.locator('input#password').fill(newPassword)
await page.locator('input#confirmPassword').fill(newPassword)
// 5. Submit form
await page.getByRole('button', { name: 'Reset Password' }).click()
// 6. Verify success state
await expect(page.getByText('Password reset successfully!')).toBeVisible()
// 7. Click Go to Login
await page.getByRole('button', { name: 'Go to Login' }).click()
await expect(page).toHaveURL('/login')
// 8. Log in with the new password
await loginViaUi(page, email, newPassword)
await expect(page).toHaveURL(/\/teams\/[^/]+/)
await expect(page.getByRole('heading', { name: 'Projects' })).toBeVisible()
})
@@ -40,8 +40,8 @@ test('owner should create a project with a cover image', async ({ owner, prisma
await expect(page).toHaveURL(/\/projects\/[^/]+/)
await expect(page.locator(`text=${projectName}`).first()).toBeVisible()
// Back on the dashboard the new project card is visible with its cover
await page.click('button[aria-label="Dashboard"]')
// Back on the home page the new project card is visible with its cover
await page.click('button[aria-label="Home"]')
await expect(page).toHaveURL(/\/teams\/[^/]+/)
await expect(page.locator(`img[alt="${projectName}"]`)).toBeVisible()
@@ -0,0 +1,35 @@
import { expect, test } from '../../fixtures'
import { fileCard } from '../../helpers/files'
test('owner views a file and it appears in recents', async ({ file }) => {
const { page, projectId, fileName, fileId } = file
// Open the file details page to record view
await page.goto(`/projects/${projectId}/files/${fileId}`)
await expect(page.getByText(fileName).first()).toBeVisible()
// Navigate to Recents page via sidebar or direct URL
await page.goto(`/projects/${projectId}`)
await page.getByText('Recently Viewed').first().click()
await expect(page).toHaveURL(new RegExp(`/projects/${projectId}/recents`))
// The viewed file should be visible in recents
const card = fileCard(page, fileName)
await expect(card).toBeVisible()
// Toolbar should show hint text instead of action buttons
await expect(
page.getByText('This page displays the 100 most recent files you viewed in this project.'),
).toBeVisible()
await expect(page.getByRole('button', { name: 'Field' })).not.toBeVisible()
await expect(page.getByRole('button', { name: 'Search' })).not.toBeVisible()
await expect(page.getByText('AGENTS.md')).not.toBeVisible()
// Right-clicking the file should NOT show the context menu
await card.click({ button: 'right' })
await expect(page.getByRole('menuitem', { name: 'Delete' })).not.toBeVisible()
await expect(page.getByRole('menuitem', { name: 'Download' })).not.toBeVisible()
// The per-item overflow menu must also be unavailable on the read-only Recents page.
await expect(card.getByRole('button')).toHaveCount(0)
})
@@ -0,0 +1,126 @@
import { expect, test } from '../../fixtures'
test('owner manages resource quotas in settings and resets usage from the dashboard', async ({
owner,
prisma,
}) => {
const { page, teamId, email } = owner
// 1. Navigate to team settings
await page.goto(`/teams/${teamId}/settings`)
// 2. Click the Quotas sidebar tab
await page.getByRole('button', { name: /Quotas|配额/i }).click()
// Verify URL contains #quotas and remains after reload
expect(page.url()).toContain('#quotas')
await page.reload()
expect(page.url()).toContain('#quotas')
// 3. Verify Quotas settings card is displayed with empty state
await expect(page.getByRole('heading', { name: /^(Resource Quotas|资源配额)$/i })).toBeVisible()
await expect(page.getByText(/No resource quotas configured|暂未配置资源配额/i)).toBeVisible()
// 4. Open Create Quota Dialog
await page
.getByRole('button', { name: /Add Quota|添加配额/i })
.first()
.click()
await expect(page.getByText(/Create Quota Rule|创建配额规则/i)).toBeVisible()
// 5. Fill and submit new quota rule
await page.fill('#quota-limit', '50000')
await page.getByRole('button', { name: /^(Create|创建)$/i }).click()
// 6. Verify quota rule card appears in the list
await expect(page.getByText(/50,000 tokens|50000 tokens/i)).toBeVisible()
await expect(page.getByText(/Each Member|每个成员/i)).toBeVisible()
// Verify in database
const createdRule = await prisma.quotaRule.findFirst({
where: { teamId, limit: 50000 },
})
expect(createdRule).not.toBeNull()
expect(createdRule?.enabled).toBe(true)
// 7. Usage is now monitored from the dashboard, not the settings rule card.
await expect(page.getByRole('button', { name: /View Usage|查看使用量/i })).not.toBeVisible()
// 8. Toggle quota rule switch
await page.getByRole('switch').click()
await expect(page.getByRole('switch')).not.toBeChecked()
const disabledRule = await prisma.quotaRule.findFirst({
where: { id: createdRule?.id },
})
expect(disabledRule?.enabled).toBe(false)
// Toggle back on
await page.getByRole('switch').click()
await expect(page.getByRole('switch')).toBeChecked()
// 9. Open Edit Dialog by clicking the quota card
await page.getByText(/50,000 tokens|50000 tokens/i).click()
await expect(page.getByText(/Edit Quota Rule|编辑配额规则/i)).toBeVisible()
await expect(page.getByRole('button', { name: /Each Member|每个成员/i })).toBeDisabled()
await expect(page.locator('#quota-resource')).toBeDisabled()
// 10. Update limit
await page.fill('#quota-limit', '75000')
await page.getByRole('button', { name: /^(Save|保存)$/i }).click()
// Verify updated limit in UI and DB
await expect(page.getByText(/75,000 tokens|75000 tokens/i)).toBeVisible()
const updatedRule = await prisma.quotaRule.findFirst({
where: { id: createdRule?.id },
})
expect(updatedRule?.limit).toBe(75000)
// 11. Verify quota usage and reset it from the dashboard
const ownerUser = await prisma.user.findUnique({ where: { email } })
expect(ownerUser).not.toBeNull()
await prisma.quotaRecord.create({
data: {
ruleId: createdRule?.id as string,
teamId,
userId: ownerUser?.id,
periodStart: new Date(),
periodEnd: new Date(Date.now() + 24 * 60 * 60 * 1000),
consumed: 100,
},
})
await page.goto(`/teams/${teamId}/dashboard`)
await page.getByRole('button', { name: /Quotas|配额/i }).click()
await expect(
page.getByText(/Monitor live quota usage|在仪表盘中监控实时配额使用情况/),
).toBeVisible()
const quotaRuleButton = page.getByRole('button', { name: /Expand quota rule|展开配额规则/i })
await quotaRuleButton.click()
await expect(page.getByText(/^100 \/ 75,000 tokens$|^100 \/ 75000 tokens$/i)).toBeVisible()
await page.getByRole('button', { name: /Reset Usage|重置使用量/i }).click()
await expect(page.getByRole('alertdialog')).toBeVisible()
await page.getByRole('button', { name: /Confirm|确认/i }).click()
await expect(page.getByText(/^0 \/ 75,000 tokens$|^0 \/ 75000 tokens$/i)).toBeVisible()
const resetRecord = await prisma.quotaRecord.findFirst({
where: { ruleId: createdRule?.id, userId: ownerUser?.id },
})
expect(resetRecord?.consumed).toBe(0)
// 12. Delete quota rule from settings
await page.goto(`/teams/${teamId}/settings`)
await page.getByRole('button', { name: /Quotas|配额/i }).click()
await page.getByRole('button', { name: 'Quota actions' }).first().click()
await page.getByRole('menuitem', { name: /Delete|删除/i }).click()
await page
.getByRole('button', { name: /Delete|删除/i })
.last()
.click()
// Verify empty state returns
await expect(page.getByText(/No resource quotas configured|暂未配置资源配额/i)).toBeVisible()
const deletedRule = await prisma.quotaRule.findFirst({
where: { id: createdRule?.id },
})
expect(deletedRule).toBeNull()
})
+5 -5
View File
@@ -1,6 +1,6 @@
{
"name": "@shumai/web-app",
"version": "0.3.8",
"version": "0.4.6",
"private": true,
"type": "module",
"dependencies": {
@@ -12,11 +12,11 @@
"@shumai/agent": "workspace:*",
"@shumai/transcode": "workspace:*",
"@shumai/webui": "workspace:*",
"hono": "4.12.23"
"hono": "4.13.5"
},
"devDependencies": {
"@prisma/adapter-pg": "7.8.0",
"pg": "8.21.0",
"@types/pg": "8.20.0"
"@prisma/adapter-pg": "7.10.0",
"@types/pg": "8.23.1",
"pg": "8.23.0"
}
}
+31
View File
@@ -11,21 +11,52 @@ import { assetService } from '@shumai/core/src/asset/asset'
import { metadataService } from '@shumai/core/src/metadata/metadata'
import { initTranscodeWorkflows } from '@shumai/transcode'
import { workflowService } from '@shumai/workflow-core'
import { migrateLegacyAgentAvatars } from '@shumai/core/src/agent/migration'
import { handleDaemonCommands } from '@shumai/core/src/utils/daemon'
import { authService } from '@shumai/core/src/auth/auth'
import { sandboxService } from '@shumai/core'
if (process.argv.includes('--check')) {
console.log('✅ Web app evaluated successfully!')
process.exit(0)
}
const cliArgs = process.argv.slice(2)
const resetCmdIndex = cliArgs.findIndex(
(arg) => arg === 'reset-password' || arg === 'reset-passowrd',
)
if (resetCmdIndex !== -1) {
const email = cliArgs[resetCmdIndex + 1]
if (!email || email.startsWith('-')) {
console.error('Error: Please provide a valid email address.')
console.error('Usage: shumai reset-password <email>')
process.exit(1)
}
try {
const link = await authService.generatePasswordResetLink(email)
console.log(link)
process.exit(0)
} catch (err: unknown) {
const message = err instanceof Error ? err.message : 'Unknown error'
console.error(`Error: ${message}`)
process.exit(1)
}
}
async function run() {
// Initialize workflows and activities for local executor mode
initAgentWorkflows()
initTranscodeWorkflows()
await sandboxService.ensureInitialized().catch((err) => {
console.error('Failed to eagerly initialize sandbox in web app:', err)
})
// Start services
await metadataService.syncSystemFields().catch(console.error)
await migrateLegacyAgentAvatars().catch(console.error)
assetService.startCleanupJob()
workflowService.start()
if (process.env.WORKFLOW_EXECUTOR === 'temporal') {
+1227 -1107
View File
File diff suppressed because it is too large Load Diff
+8 -2
View File
@@ -35,6 +35,7 @@
"using-shumai/metadata",
"using-shumai/collections",
"using-shumai/share-links",
"using-shumai/nle-and-premiere",
"using-shumai/gotenberg"
]
},
@@ -42,6 +43,7 @@
"group": "Shumai Agent Settings",
"pages": [
"using-shumai/agent-providers",
"using-shumai/image-video-generation",
"using-shumai/agents",
"using-shumai/agents-md",
"using-shumai/agent-skills",
@@ -51,8 +53,12 @@
]
},
{
"group": "Media Transcoding Settings",
"pages": ["using-shumai/transcode-settings"]
"group": "Team Settings",
"pages": [
"using-shumai/transcode-settings",
"using-shumai/quotas-settings",
"using-shumai/password-reset"
]
},
{
"group": "Configuration",
Binary file not shown.

Before

Width:  |  Height:  |  Size: 309 KiB

After

Width:  |  Height:  |  Size: 131 KiB

+40 -13
View File
@@ -5,7 +5,7 @@ description: Configure the tools and capabilities permitted for each agent.
Shumai agents are equipped with built-in tools that allow them to interact with the file system, view files, extract video frames, and execute commands.
By default, **all tools are enabled** for new agents. Team Owners can deny specific tools to restrict agent capabilities.
By default, most tools are enabled for new agents, while sensitive or destructive tools (such as **Delete Asset**) are disabled by default. Team Owners can toggle specific tools to customize agent capabilities.
<Warning>
**Caution:** Disabling tools can cause agents or skills to fail. For example, disabling the
@@ -30,36 +30,63 @@ The following tools can be individually toggled in the agent configuration dialo
- **Description:** Allows the agent to load and read skill definitions to perform specialized actions.
- **Why it matters:** Enables the agent to inspect the instructions/configurations of custom skills registered in your workspace before executing them.
### 3. Analyze Image (`analyze_image`)
### 3. Read Asset (`read_asset`)
- **Description:** Allows the agent to view and analyze the visual contents of an image file.
- **Why it matters:** Enables multimodal agents to "see" image assets uploaded to Shumai, allowing them to answer comments or write metadata about images.
- **Description:** Allows the agent to inspect images, extract still frames from video files, render PDF document pages, and read text/markdown documents.
- **Why it matters:** Enables multimodal agents to view visual media assets uploaded to Shumai, extract frame-by-frame video screenshots, inspect document layouts, and answer questions about uploaded creative assets.
### 4. Video Frame Extraction (`screenshot`)
- **Description:** Allows the agent to extract still image frames from video files for analysis.
- **Why it matters:** Enables the agent to perform frame-by-frame analysis on videos (e.g. for comments, annotation, or search).
### 5. Browse Shumai (`list_assets`)
### 4. Browse Shumai (`list_assets`)
- **Description:** Allows the agent to list folders and browse files in Shumai.
- **Why it matters:** Gives the agent visual mapping of the project structure so it can search for other files or locate related assets.
### 6. Create Folder (`create_folder`)
### 5. Create Folder (`create_folder`)
- **Description:** Allows the agent to create new folders in Shumai.
- **Why it matters:** Needed if the agent organizes outputs or places files in custom subdirectory folders.
### 7. Create File (`create_file`)
### 6. Create File (`create_file`)
- **Description:** Allows the agent to create and upload new files to Shumai.
- **Why it matters:** Allows the agent to generate new assets (e.g. text logs, transcoded clips, reports) and save them directly back into your project.
### 8. Create Version (`create_version`)
### 7. Create Version (`create_version`)
- **Description:** Allows the agent to upload and stack a new version of an existing file in Shumai.
- **Why it matters:** Allows the agent to update files in a clean, non-destructive way by stacking revisions rather than creating duplicate files.
### 8. Generate Image (`generate_image`)
- **Description:** Allows the agent to generate still images from text prompts and reference images using configured AI image models.
- **Why it matters:** Enables agents to create concept art, mockups, textures, and illustrations directly inside Shumai.
- **Prerequisite:** This tool requires at least one image model to be configured and enabled in [Image / Video Generation](/using-shumai/image-video-generation). If no image models are enabled under a configured provider, this tool is omitted from the agent session even if enabled in the agent settings dialog.
### 9. Generate Video (`generate_video`)
- **Description:** Allows the agent to generate video clips from text prompts, image animation, or transition keyframes using configured AI video models.
- **Why it matters:** Enables agents to produce short animated clips, camera motion shots, and video transitions.
- **Prerequisite:** This tool requires at least one video model to be configured and enabled in [Image / Video Generation](/using-shumai/image-video-generation). If no video models are enabled under a configured provider, this tool is omitted from the agent session even if enabled in the agent settings dialog.
### 10. Download Asset (`download_asset`)
- **Description:** Allows the agent to download a workspace asset or specific storage S3 key to the local `.pi` directory for processing with local scripts or bash commands.
- **Why it matters:** Enables agents executing custom skill scripts to fetch files or intermediate transcode artifacts to local disk.
### 11. Rename Asset (`rename_asset`)
- **Description:** Allows the agent to rename an existing file or folder in Shumai.
- **Why it matters:** Enables agents to keep project files neatly named and organized according to workspace naming conventions. Enabled by default.
### 12. Move Assets (`move_assets`)
- **Description:** Allows the agent to move one or more assets to a destination parent folder.
- **Why it matters:** Enables agents to reorganize workspace structures, relocate generated outputs, or tidy up project folders. Enabled by default.
### 13. Delete Asset (`delete_asset`)
- **Description:** Allows the agent to delete a single file or folder by moving it to the Trash bin.
- **Why it matters:** Provides agents with the ability to clean up outdated or redundant assets. To prevent accidental data loss, this tool is **disabled by default** and strictly limited to deleting one asset at a time. Team Owners must explicitly enable this tool for an agent.
---
## Restricting Tools
@@ -0,0 +1,141 @@
---
title: Image / Video Generation
description: Configure image and video generation providers and models for built-in AI agent tools.
---
Shumai agents can generate creative visual assets directly within your workspace using built-in agent tools: **Generate Image** (`generate_image`) and **Generate Video** (`generate_video`).
Because generating visual media requires specialized foundation models, you must configure upstream media providers and enable specific models in your team settings before agents can use these capabilities.
> 🔒 **Access Control:** Only **Team Owners** can view and configure media generation settings. To access this page, click your avatar, navigate to **Settings**, and select **Image / Video Generation** from the left sidebar (or navigate to `teams/<teamId>/settings#image-video`).
---
## Why This Setting Is Needed
Conversational AI models (configured under **AI Providers**) handle text reasoning and chat interactions, but image and video generation require dedicated multimodal generative models (such as DALL-E, FLUX, Gemini Image, Veo, Kling AI, Luma Ray, Wan, and others).
The **Image / Video Generation** settings page allows team owners to:
1. Authenticate with one or more supported image and video generation providers.
2. Select which curated models to enable for your team, or register custom model IDs.
3. Establish default models for agents when generating visual assets.
---
## Tool Availability & Activation Rules
<Warning>
**Important:** Enabling `generate_image` or `generate_video` in an agent's configuration dialog is
**not enough** on its own. The tool will only be available to the agent if all three of the
following conditions are met:
</Warning>
1. **Provider Configured:** The provider must have a valid API key (either set via server environment variables or configured with a custom team key).
2. **At Least One Model Enabled:** There must be **at least one enabled model** for that modality (`image` or `video`) under an active provider.
3. **Tool Permitted for Agent:** The tool must not be disabled in the agent's tool permissions list under **Team Settings** > **Agents** > **Tools**.
### What Happens If No Models Are Configured?
If no image models are enabled under a configured provider, the `generate_image` tool is **completely omitted** from the agent's runtime environment. Similarly, if no video models are enabled, the `generate_video` tool is omitted.
In this state:
- The agent **cannot call** the generation tool.
- The tool will not appear in the agent's tool catalog or prompt definition.
- Even if a Team Owner has toggled **Generate Image** or **Generate Video** ON in the agent's settings dialog, the agent will not have access to the tool until a model is enabled.
---
## Supported Providers
Shumai provides built-in support for 18 media generation providers:
| Provider | Supported Modalities | Default Environment Variable |
| :-------------------- | :------------------- | :--------------------------- |
| **OpenAI** | Image | `OPENAI_API_KEY` |
| **Google** | Image, Video | `GEMINI_API_KEY` |
| **Google Vertex AI** | Image, Video | `GOOGLE_CLOUD_API_KEY` |
| **xAI** | Image, Video | `XAI_API_KEY` |
| **Fal** | Image, Video | `FAL_KEY` |
| **Replicate** | Image, Video | `REPLICATE_API_TOKEN` |
| **Black Forest Labs** | Image, Video | `BFL_API_KEY` |
| **Kling AI** | Video | `KLINGAI_API_KEY` |
| **Together AI** | Image | `TOGETHER_API_KEY` |
| **Fireworks AI** | Image | `FIREWORKS_API_KEY` |
| **DeepInfra** | Image | `DEEPINFRA_API_KEY` |
| **Luma** | Image | `LUMA_API_KEY` |
| **Amazon Bedrock** | Image | `AWS_ACCESS_KEY_ID` |
| **Alibaba** | Video | `ALIBABA_API_KEY` |
| **ByteDance** | Image, Video | `ARK_API_KEY` |
| **MiniMax** | Video | `MINIMAX_API_KEY` |
| **Prodia** | Image, Video | `PRODIA_TOKEN` |
| **Azure OpenAI** | Image | `AZURE_API_KEY` |
---
## Configuring Providers & API Keys
Clicking on any provider in the **Media Providers** list opens its configuration dialog:
### Provider Statuses
- **Configured (Custom)**: A team-specific API key or custom environment variable name was entered in this dialog.
- **Configured (Environment)**: The system detected a server-level default environment variable (e.g. `OPENAI_API_KEY`). No team key is required unless you want to override it.
- **Not Configured**: No API key is available. You must provide an API key or an environment variable name to use this provider.
### Overriding API Keys
In the **API Key** tab of the provider dialog:
- Enter an API key literal (e.g. `sk-...`) or a custom environment variable name available on the host system.
- Click **Clear Custom Key** to revert back to using the default environment variable if one exists.
---
## Managing Models
In the **Models** tab of the provider dialog:
### Curated Models
Shumai comes pre-configured with popular curated models (such as `dall-e-3`, `fal-ai/flux/dev`, `veo-3.1-generate`, `kling-v3.0-t2v`, etc.). Toggle the switch next to any model to enable or disable it for your team.
### Custom Models
If your provider supports a new or fine-tuned model not listed in the curated models:
1. Select the modality (**Image** or **Video**).
2. Enter the exact **Model ID** recognized by the upstream provider.
3. Click **Add**.
### Default Model Selection
The **first enabled model** of each type (`image` or `video`) automatically becomes the default model. When an agent calls `generate_image` or `generate_video` without explicitly specifying a `model` parameter, Shumai automatically directs the generation request to this default model.
---
## How Agents Use Generation Tools
Once enabled, agents can invoke the tools during conversations or automated workflows:
### 1. Generate Image (`generate_image`)
- **Prompt:** Detailed text description of the image.
- **Model Selection:** Automatically defaults to your first enabled image model, or the agent can choose any enabled model in `provider:modelId` format (e.g. `openai:dall-e-3` or `fal:fal-ai/flux/dev`).
- **Image References:** Agents can use existing workspace assets as style or composition references by passing S3 storage keys obtained from the `read_asset` tool (`s3KeyOnly: true`).
- **Inpainting:** Supports mask-guided localized image editing using an S3 mask key.
- **Parameters:** Custom aspect ratios (`1:1`, `16:9`, `9:16`, `4:3`, `3:4`, `2:3`, `3:2`), dimensions, and seeds.
### 2. Generate Video (`generate_video`)
- **Generation Modes:**
- `text_to_video`: Generate a clip from a descriptive motion prompt.
- `image_to_video`: Animate an existing still image asset.
- `first_last_frame`: Seamlessly interpolate and transition between two keyframe assets.
- `reference_to_video`: Use reference images for consistent characters or environments.
- **Parameters:** Aspect ratio (`16:9`, `9:16`, `1:1`, `adaptive`), resolution, duration, frame rate (FPS), and audio generation.
### Asset Creation Workflow
All generated media files are initially saved to the local sandboxed directory (`.pi/`). Agents can then use **Create File** (`create_file`) to upload the output as a new project asset or **Create Version** (`create_version`) to stack it onto an existing revision history.
+126
View File
@@ -0,0 +1,126 @@
---
title: NLE Export & Premiere Pro Plugin
description: Export timestamped review comments to popular NLE formats or use the native Premiere Pro UXP plugin to import assets and auto-sync timeline markers.
---
Shumai integrates directly into video editing workflows. You can export review comments into industry-standard non-linear editor (NLE) marker formats from the web interface, or use the native Adobe Premiere Pro UXP plugin to import media assets and synchronize comments to timeline markers in real-time.
---
## Comments Export to NLE
Comments left during video and audio reviews can be exported directly from the web interface to external editing software.
### How to Export Comments
1. Open any video or audio asset in the Shumai media viewer.
2. In the right sidebar, navigate to the **Comments** tab.
3. Click the **More Options** (`...`) menu located next to **All Comments**.
4. Hover over **Export Comments** and select your editing software format:
| Format | File Extension | Target Software |
| :----------------- | :------------- | :--------------------------------- |
| **Premiere Pro** | `.xml` | Adobe Premiere Pro marker sequence |
| **Resolve** | `.edl` | DaVinci Resolve timeline markers |
| **FCP 10.4.0+** | `.fiojson` | Apple Final Cut Pro marker data |
| **Media Composer** | `.xml` | Avid Media Composer markers |
Once downloaded, import the marker file into your editing software to overlay all review notes and timestamps onto your timeline.
---
## Premiere Pro UXP Plugin (Experimental)
The official Shumai Premiere Pro UXP plugin provides a native panel inside Adobe Premiere Pro, enabling editors to browse workspace assets, import media or proxies directly into the project bin, and automatically synchronize review comments to sequence markers.
> [!NOTE]
> **Experimental Feature:**
> The Premiere Pro UXP plugin is currently experimental. While functional, it has not yet been tested across all Premiere Pro minor versions and operating system configurations. If you encounter any bugs, unexpected behavior, or have workflow suggestions, please [open an issue on GitHub](https://github.com/shumaiOne/shumai/issues) or join our [Discord community](https://discord.gg/sUzhujK6DD).
### Minimum Version Requirements
| Software | Minimum Version Required |
| :--------------------- | :------------------------------------------------ |
| **Adobe Premiere Pro** | **`25.1.0`** or higher (Premiere Pro 2025 v25.1+) |
| **Shumai Server** | **`0.4.6`** or higher |
---
### Installation
You can install the Shumai Premiere Pro plugin using either the packaged `.ccx` installer or the Adobe UXP Developer Tools.
#### Option 1: Install via Creative Cloud (.ccx)
This is the recommended and quickest installation method for standard users.
> [!IMPORTANT]
> **Prerequisites:**
>
> - You must have **Adobe Premiere Pro** (v25.1.0+) and the **Adobe Creative Cloud desktop application** installed on your system.
> - Adobe Premiere Pro must be recognized and listed in the Creative Cloud desktop app under your installed applications.
1. Download the pre-built plugin package [`shumai-premiere.ccx`](https://github.com/shumaiOne/shumai/raw/main/apps/premiere-uxp/shumai-premiere.ccx) from the repository (located at `apps/premiere-uxp/shumai-premiere.ccx`).
2. Double-click the downloaded `.ccx` file, or drag and drop it directly into the **Adobe Creative Cloud** desktop app.
3. Follow the on-screen prompts in Creative Cloud to approve and install the plugin.
4. Launch or restart Adobe Premiere Pro.
#### Option 2: Install via Adobe UXP Developer Tools (UDT)
This method is intended for developers or users building from source code.
> [!NOTE]
> Refer to the official [Adobe UXP Developer Tools Documentation](https://developer.adobe.com/premiere-pro/uxp/getting-started/quickstart/) for details on installing and setting up the UXP Developer Tool (UDT).
1. Clone the Shumai repository:
```bash
git clone https://github.com/shumaiOne/shumai.git
cd shumai
```
2. Install dependencies and build the UXP plugin:
```bash
bun install
bun run --filter @shumai/premiere-uxp build
```
3. Open the **Adobe UXP Developer Tool** (UDT).
4. Click **Add Plugin** and select the manifest file located at:
```text
apps/premiere-uxp/dist/manifest.json
```
_(Or `apps/premiere-uxp/public/manifest.json` when running in watch mode)._
5. Open Adobe Premiere Pro. In the UDT application, find the Shumai plugin in your list, click the `•••` action menu, and select **Load** (or **Load & Watch**).
---
### Connecting to Your Shumai Server
1. In Premiere Pro, open the plugin panel by navigating to **Window** > **Extensions** > **Shumai** (or **Window** > **Shumai**).
2. Enter your connection credentials:
- **Endpoint URL:** The URL of your Shumai server (e.g. `http://localhost:3000` or `https://shumai.yourdomain.com`).
- **API Key:** A valid API key generated in Shumai. To create one, open Shumai in your browser, go to **Team Settings** > **Developer**, and generate a new API key.
3. Click **Connect**. Once connected, your credentials are saved locally in Premiere Pro.
---
### What the Shumai UXP Plugin Can Do
The plugin integrates two core workflows directly into Premiere Pro:
#### 1. Browse & Import Assets into Premiere Pro
- **Browse & Search:** Navigate through your Shumai projects, folders, and media assets with breadcrumb navigation and instant search.
- **Choose Download Quality:** Select **Import** on any asset to choose between:
- **Original (Raw):** Downloads and imports the full original master media file.
- **Video Proxy:** Downloads and imports an optimized proxy transcode (e.g. 1080p, 720p, 540p, or 360p MP4) for lighter, smoother editing playback.
- **Native Destination Selection:** Prompts a native system folder picker so you can choose exactly where on your local disk the media file should be saved.
- **Automatic Bin Import:** After saving to disk, the file is automatically imported into your active Premiere Pro project bin.
#### 2. Auto-Sync Comments to Sequence Markers
- **Link Sequence:** In the plugin file list, select **Link Sequence** on any video asset to link it with your currently active timeline sequence.
- **Automatic Marker Creation:** The plugin immediately fetches existing comments from Shumai and converts them into native Premiere Pro sequence markers:
- **Accurate Timestamps:** Comments placed at specific timecodes appear at the corresponding timeline frames. Comments without timestamps are placed at the beginning of the sequence (`00:00:00:00`).
- **Author & Content:** The marker name shows the commenter's name, and the marker notes include the comment body along with formatted threaded replies.
- **Continuous Background Sync:** The plugin continuously syncs in the background (every 12 seconds), and triggers an immediate sync whenever you switch focus to the panel or activate a sequence.
- **Sequences Dashboard:** Switch to the **Sequences** tab at any time to see all linked sequences in your project, view the last sync time, trigger an instant manual sync, or unlink sequences.
- **Clean Unlink:** When unlinking an asset from a sequence, Shumai cleanly cleans up the markers it generated without affecting other project markers.
+60
View File
@@ -0,0 +1,60 @@
---
title: Password Reset
description: How administrators generate secure password reset links for team members.
---
Because Shumai does not require an external email delivery service (SMTP) to be configured for standard self-hosted deployments, password resets are initiated securely by an administrator using the Shumai CLI.
---
## Overview
When a user forgets their password, an administrator can generate a one-time password reset link directly from the command line.
- **Link Expiration**: The generated password reset link is valid for **1 hour** (`3600 seconds`).
- **One-Time Use**: Once used, the token is permanently invalidated.
- **Session Revocation**: When a user resets their password, all existing active sessions for that account are automatically revoked across all devices.
- **Latest Link Validity**: Generating a new reset link for a user immediately supersedes any previously generated pending links.
---
## Generating a Password Reset Link
### Running on Local Host / Server
Run the `reset-password` subcommand from your Shumai installation directory:
```bash
shumai reset-password <user-email>
```
_(Alternatively, `bun apps/web/src/index.ts reset-password <user-email>`)_
**Example Output:**
```text
http://localhost:3000/reset-password?token=bb3xg4uO3cwN0FQv4cgUK6Hh
```
### Running inside Docker
If Shumai is running inside a Docker container, execute the command using `docker exec`:
```bash
docker exec -it <container-name-or-id> shumai reset-password <user-email>
```
> [!TIP]
> Both `shumai` and the common alias `shuami` (e.g. `shuami reset-password <user-email>`) are supported.
> [!NOTE]
> For remote servers or production deployments, ensure `BETTER_AUTH_URL` is set in your environment (e.g., `BETTER_AUTH_URL=https://shumai.example.com`) so the CLI generates the reset link with your public domain instead of `localhost`.
---
## Member Reset Experience
1. The administrator sends the generated URL to the team member via their preferred secure communication channel.
2. The user opens the link in their browser.
3. The user inputs their **New Password** and **Confirm Password** (minimum 3 characters).
4. Upon clicking **Reset Password**, the password is securely updated, all previous active sessions are invalidated, and the user is redirected to `/login` to sign in.
+121
View File
@@ -0,0 +1,121 @@
---
title: Resource Quotas
description: Configure team resource quotas, monitor live usage, and reset quota windows from the dashboard.
---
AI workflows and media processing tools can consume significant compute and API credits. Shumai provides a **Resource Quotas** system that allows Team Owners to set granular rate limits, govern budgets, and monitor real-time usage across team members and roles.
---
## Overview
Resource Quotas allow you to define maximum usage limits across specific time windows (e.g., hourly, daily, or weekly). When a member or team reaches their assigned quota, further actions for that resource are safely blocked until the quota period resets.
Quota configuration and usage monitoring are separate parts of the team experience:
- To create and manage quota rules, open **Team Settings** and navigate to the **Quotas** tab.
- To monitor live usage, open the **Team Dashboard** and select **Quotas** under the **TEAM** section.
The quota dashboard is available to Team Owners.
---
## Scope Modes
When creating or editing a quota rule, you can define how the limit is applied:
### 1. Each Member
- **Behavior**: Every member in the scope receives their own independent limit. Usage by one member does not affect the remaining quota of others.
- **Optional Role Filter**: You can restrict the quota to members with a specific role (e.g. only **Editors** or **Reviewers**), or apply it to the entire team.
- **Use Case**: Give each editor a daily budget of 100,000 tokens.
### 2. All Members (Shared Pool)
- **Behavior**: The quota limit is shared as a collective pool across all matching members. Every member's consumption draws from the same total.
- **Optional Role Filter**: Apply the shared pool to all team members or restrict it to a specific role.
- **Use Case**: Cap the total team spending on AI models to $50 per day.
### 3. Selected Members
- **Behavior**: Assign individual limits to specific chosen team members.
- **Use Case**: Grant higher limits to senior artists or technical directors while keeping standard limits for others.
---
## Supported Resource Types
Shumai supports quota enforcement across multiple layers of the AI and agent architecture:
| Resource Type | Description | Target Specification |
| :-------------------------- | :-------------------------------------------------------------------------------------- | :----------------------------------- |
| **Total Tokens** | Total LLM input and output tokens consumed in chat, comments, and autofill. | Team, Role, or Members |
| **AI Cost ($)** | Dollar expenditure accrued from AI model providers. | Team, Role, or Members |
| **MCP Server Calls** | Number of tool invocations directed to a connected Model Context Protocol (MCP) server. | Target MCP Server ID |
| **Sandboxed Bash Commands** | Shell commands executed by the agent inside the isolated sandbox. | Wildcard pattern (e.g. `npm *`, `*`) |
| **Agent Tool Calls** | Calls to specific native tools (e.g. `read_asset`, `download_asset`, `create_file`). | Tool name |
### Bash Command Wildcard Matching
For sandboxed bash execution, you can restrict specific command patterns using wildcards (`*` and `?`):
- `*`: Matches any bash command execution.
- `npm *`: Matches any npm command (e.g., `npm install`, `npm test`).
- `git commit*`: Matches git commit invocations.
---
## Time Periods & Rollover
Quotas can be configured with the following reset periods:
- **1 Hour** (`1hour`)
- **5 Hours** (`5hour`)
- **1 Day** (`1day`)
- **7 Days** (`7day`)
### Lazy Reset Mechanism
Shumai tracks usage windows automatically. When a period window expires, the system resets the quota upon the member's next request, seamlessly starting a fresh window without requiring background maintenance tasks.
---
## Monitoring Live Usage
Team Owners can inspect live consumption from the team dashboard:
1. Open the **Team Dashboard**.
2. Select **Quotas** under the **TEAM** section.
3. Quota rules are shown as first-level collapsible entries.
4. Expand a rule to view its usage records.
Each usage record displays:
- **Consumption Status**: Progress bar showing consumed units versus the total limit.
- **Remaining Allowance**: Percentage and numerical amount remaining.
- **Refresh Countdown**: Remaining time until the active window resets (e.g., _"Refreshes in 45m"_).
- **Target**: The team shared pool, role pool, or individual member associated with the record.
- **Member Search**: For member-scoped rules, search the usage records by member name or email.
Usage records are loaded when a rule is expanded and refresh automatically while the rule is open.
### Manually Resetting a Usage Record
Each usage record includes a **Reset Usage** action. After confirming the action:
- Consumption is set to zero.
- The quota period starts immediately.
- The period ends after the configured quota duration.
- For example, resetting a one-day quota at 10:00 starts a new window from 10:00 until 10:00 the following day.
A reset can also initialize a zero-consumption record for a member or shared pool that has not received usage yet. Resets are recorded in the team audit log.
---
## Managing Quota Rules
- **Enable / Disable**: Toggle the switch on any quota card in Team Settings to temporarily pause or resume enforcement without deleting the rule.
- **Edit Rules**: Click any quota card in Team Settings to update limits, change reset periods, or adjust member selections.
- **Delete Rules**: Open the card action menu (`⋮`) in Team Settings and select **Delete** to remove the quota rule.
Quota usage is monitored and reset from the Team Dashboard rather than from the settings rule cards.
+2 -1
View File
@@ -22,7 +22,7 @@ const baseNamingConvention = [
filter: {
// Allow CSS variables, common HTTP headers, library-specific names, paths, and hyphenated/numeric keys
regex:
'^(Authorization|Content-Type|Accept|--.*|string_contains|disableCSRFCheck|X-Frameio-.*|/.*|field-.*|class-name|icon-.*|[0-9]+|@typescript-eslint/.*|Variables|Read|Edit|Admin|Bucket|Key|Body|ContentLength|ContentType|Prefix|ContinuationToken|Signature)$',
'^(Authorization|Content-Type|Accept|--.*|string_contains|disableCSRFCheck|X-Frameio-.*|/.*|field-.*|class-name|icon-.*|[0-9]+|@typescript-eslint/.*|Variables|Read|Edit|Admin|Bucket|Key|Body|ContentLength|ContentType|Prefix|ContinuationToken|Signature|CopySource|Delete|Objects|Quiet|ResponseContentDisposition|UploadId|PartNumber)$',
match: false,
},
},
@@ -74,6 +74,7 @@ export default tseslint.config(
'**/packages/db/src/generated/**',
'**/packages/core/src/generated/**',
'**/data/**',
'**/packages/core/src/provider/generator/**',
'**/packages/webui/components/ui/**',
'**/packages/webui/paraglide/**',
'**/packages/webui/public/**',
+17 -17
View File
@@ -1,6 +1,6 @@
{
"name": "shumai",
"version": "0.3.8",
"version": "0.4.6",
"private": true,
"type": "module",
"repository": {
@@ -13,8 +13,8 @@
],
"scripts": {
"dev": "bun run --hot apps/web/src/index.ts",
"i18n:compile": "paraglide-js compile --project ./packages/webui/project.inlang --outdir ./packages/webui/paraglide --emit-ts-declarations --no-emit-git-ignore",
"i18n:watch": "paraglide-js compile --project ./packages/webui/project.inlang --outdir ./packages/webui/paraglide --watch --emit-ts-declarations --no-emit-git-ignore",
"i18n:compile": "paraglide-js compile --project ./packages/webui/project.inlang --outdir ./packages/webui/paraglide --emit-ts-declarations",
"i18n:watch": "paraglide-js compile --project ./packages/webui/project.inlang --outdir ./packages/webui/paraglide --watch --emit-ts-declarations",
"typecheck": "tsc --noEmit",
"lint": "eslint . --ext ts,tsx --report-unused-disable-directives --max-warnings 0",
"test": "bun --bun vitest run",
@@ -30,8 +30,8 @@
"db:generate": "cd packages/db && bunx prisma generate",
"worker:agent": "bun apps/agent/src/index.ts",
"worker:transcode": "bun apps/transcode/src/index.ts",
"build": "bun run build.ts",
"build-npm": "bun scripts/build-npm.ts",
"build": "bun run i18n:compile && bun run build.ts",
"build-npm": "bun run i18n:compile && bun scripts/build-npm.ts",
"prepublishOnly": "bun run build-npm && bun run lint && bun run typecheck",
"publish": "bun run prepublishOnly && bun run scripts/publish.ts",
"publish:dry": "bun run prepublishOnly && bun run scripts/publish.ts --dry-run",
@@ -42,29 +42,29 @@
},
"devDependencies": {
"@eslint/js": "10.0.1",
"@inlang/paraglide-js": "2.20.0",
"@inlang/paraglide-js": "2.25.0",
"@playwright/test": "1.61.1",
"@testcontainers/postgresql": "12.0.1",
"@testcontainers/postgresql": "12.1.0",
"@testing-library/dom": "10.4.1",
"@testing-library/react": "16.3.2",
"@types/bun": "1.3.14",
"@testing-library/react": "16.3.3",
"@types/bun": "1.4.0",
"@types/node": "25.9.1",
"bun-plugin-pino": "1.5.0",
"bun-plugin-tailwind": "0.1.2",
"bun-types": "1.3.14",
"eslint": "10.4.1",
"bun-types": "1.4.0",
"eslint": "10.9.1",
"eslint-config-prettier": "10.1.8",
"eslint-plugin-prettier": "5.5.6",
"eslint-plugin-react": "7.37.5",
"globals": "17.6.0",
"happy-dom": "20.10.6",
"globals": "17.11.0",
"happy-dom": "20.12.0",
"pino-pretty": "13.1.3",
"prisma": "7.8.0",
"testcontainers": "12.0.1",
"prisma": "7.10.0",
"testcontainers": "12.1.0",
"typescript": "6.0.3",
"typescript-eslint": "8.60.1",
"typescript-eslint": "8.68.0",
"vite-tsconfig-paths": "6.1.1",
"vitest": "4.1.8"
"vitest": "4.1.11"
},
"patchedDependencies": {
"@earendil-works/pi-ai@0.82.1": "patches/@earendil-works%2Fpi-ai@0.82.1.patch"
+9 -9
View File
@@ -1,27 +1,27 @@
{
"name": "@shumai/agent",
"version": "0.3.8",
"version": "0.4.6",
"private": true,
"type": "module",
"main": "./src/index.ts",
"types": "./src/index.ts",
"dependencies": {
"@anthropic-ai/sandbox-runtime": "0.0.66",
"@anthropic-ai/sandbox-runtime": "0.0.74",
"@earendil-works/pi-agent-core": "0.82.1",
"@earendil-works/pi-ai": "0.82.1",
"@google/genai": "1.52.0",
"@google/genai": "2.19.0",
"@shumai/core": "workspace:*",
"@shumai/db": "workspace:*",
"@shumai/dtos": "workspace:*",
"@shumai/workflow-core": "workspace:*",
"@temporalio/activity": "1.17.2",
"@temporalio/worker": "1.17.2",
"@temporalio/workflow": "1.17.2",
"adm-zip": "0.5.17",
"@temporalio/activity": "1.23.0",
"@temporalio/worker": "1.23.0",
"@temporalio/workflow": "1.23.0",
"adm-zip": "0.6.0",
"jittered-fractional-indexing": "1.0.1",
"typebox": "1.1.38",
"typebox": "1.3.22",
"ulid": "3.0.2",
"zod": "4.4.3"
"zod": "4.5.4"
},
"devDependencies": {
"@types/adm-zip": "0.5.8"
File diff suppressed because it is too large Load Diff
File diff suppressed because it is too large Load Diff
+56
View File
@@ -6,6 +6,7 @@ import {
saveAssetEmbeddingsActivity,
generateImageEmbeddingActivity,
generateVideoChunkEmbeddingActivity,
generateEmbeddingActivity,
} from './ai'
import { s3Service } from '@shumai/core/src/s3/s3'
import { transcodeService } from '@shumai/core'
@@ -35,12 +36,16 @@ vi.mock('@shumai/core/src/s3/s3', () => ({
putObject: vi.fn(),
headObject: vi.fn(),
listObjects: vi.fn(),
downloadToFile: vi.fn(),
resolveInput: vi.fn().mockImplementation(async (_bucket, key) => `https://mock-storage/${key}`),
},
}))
vi.mock('@shumai/core/src/transcode/transcode', () => ({
transcodeService: {
extractVideoFrames: vi.fn(),
createTempDir: vi.fn().mockReturnValue('/tmp'),
removeDir: vi.fn(),
},
}))
@@ -121,6 +126,33 @@ describe('AI Activities Unit Tests', () => {
)
})
it('should resolve video input via resolveInput and avoid downloadToFile in generateEmbeddingActivity', async () => {
vi.mocked(s3Service.downloadToFile).mockClear()
vi.mocked(s3Service.resolveInput).mockClear()
vi.mocked(s3Service.resolveInput).mockResolvedValue(
'https://mock-storage/files/asset-123/video.mp4',
)
const res = await generateEmbeddingActivity({
teamId: 't1',
assetId: 'asset-123',
context: {
agent: {},
asset: {
mediaType: 'video/mp4',
name: 'sample.mp4',
storageKey: { key: 'files/asset-123/video.mp4' },
media: { proxyType: 'video' },
},
},
})
expect(s3Service.resolveInput).toHaveBeenCalledWith('shumai', 'files/asset-123/video.mp4')
expect(s3Service.downloadToFile).not.toHaveBeenCalled()
expect(s3Service.getObject).not.toHaveBeenCalledWith('shumai', 'files/asset-123/video.mp4')
expect(res.embeddings.length).toBeGreaterThan(0)
})
it('should generate text embedding successfully', async () => {
const res = await generateTextEmbeddingActivity({
text: 'Search query',
@@ -190,6 +222,30 @@ describe('AI Activities Unit Tests', () => {
'image/webp',
)
})
it('should resolveInput from s3Service when filePath is not provided', async () => {
vi.mocked(s3Service.headObject).mockRejectedValue(new Error('Not Found'))
vi.mocked(s3Service.resolveInput).mockResolvedValue('https://mock-storage/project/video.mp4')
vi.mocked(transcodeService.extractVideoFrames).mockResolvedValue(['/tmp/out1.webp'])
// eslint-disable-next-line @typescript-eslint/no-explicit-any
vi.mocked(s3Service.putObject).mockResolvedValue({} as any)
const res = await extractAiMetadataActivity({
assetKey: 'project/video.mp4',
type: 'autofill',
isImage: false,
})
expect(res).toEqual(['project/ai_metadata/out1.webp'])
expect(s3Service.resolveInput).toHaveBeenCalledWith('shumai', 'project/video.mp4')
expect(transcodeService.extractVideoFrames).toHaveBeenCalledWith({
inputFile: 'https://mock-storage/project/video.mp4',
outputDir: expect.any(String),
numFrames: 30,
frameHeight: 720,
isImage: false,
})
})
})
})
+49 -35
View File
@@ -9,6 +9,7 @@ import { promisify } from 'util'
import { ApplicationFailure } from '@temporalio/activity'
import { prisma } from '@shumai/db'
import { getProxyType } from '@shumai/core/src/utils/mime'
import { ulid } from 'ulid'
const execFileAsync = promisify(execFile)
@@ -107,49 +108,52 @@ export async function generateEmbeddingActivity(params: GenerateEmbeddingParams)
throw ApplicationFailure.create({ message: 'asset has no key', nonRetryable: true })
}
const { buffer: data } = await s3Service.getObject(process.env.S3_BUCKET || 'shumai', key)
const bucket = process.env.S3_BUCKET || 'shumai'
const results: GeneratedEmbedding[] = []
if (isImage) {
const { buffer: data } = await s3Service.getObject(bucket, key)
const embVec = await generateMultimodalEmbedding(ai, data, asset.mediaType)
results.push({ embedding: embVec })
} else if (isVideo) {
const tmpFile = path.join(os.tmpdir(), `video-${Date.now()}.mp4`)
fs.writeFileSync(tmpFile, data)
const inputSource = await s3Service.resolveInput(bucket, key)
const isRemote = inputSource.startsWith('http://') || inputSource.startsWith('https://')
try {
const { stdout } = await execFileAsync('ffprobe', [
'-v',
'error',
'-show_entries',
'format=duration',
'-of',
'default=noprint_wrappers=1:nokey=1',
tmpFile,
])
const duration = parseFloat(stdout.trim())
if (isNaN(duration)) {
throw ApplicationFailure.create({
message: 'failed to parse video duration',
nonRetryable: true,
})
}
const { stdout } = await execFileAsync('ffprobe', [
'-v',
'error',
'-show_entries',
'format=duration',
'-of',
'default=noprint_wrappers=1:nokey=1',
inputSource,
])
const duration = parseFloat(stdout.trim())
if (isNaN(duration)) {
throw ApplicationFailure.create({
message: 'failed to parse video duration',
nonRetryable: true,
})
}
const chunkSize = 60.0
for (let start = 0.0; start < duration; start += chunkSize) {
let end = start + chunkSize
if (end > duration) end = duration
const chunkSize = 60.0
for (let start = 0.0; start < duration; start += chunkSize) {
let end = start + chunkSize
if (end > duration) end = duration
const chunkTmp = path.join(os.tmpdir(), `video-chunk-${Date.now()}.mp4`)
const chunkTmp = path.join(os.tmpdir(), `video-chunk-${Date.now()}-${ulid()}.mp4`)
try {
await execFileAsync('ffmpeg', [
'-y',
'-loglevel',
'warning',
'-i',
tmpFile,
...(isRemote
? ['-reconnect', '1', '-reconnect_streamed', '1', '-reconnect_delay_max', '5']
: []),
'-ss',
start.toString(),
'-i',
inputSource,
'-t',
(end - start).toString(),
'-c',
@@ -158,7 +162,6 @@ export async function generateEmbeddingActivity(params: GenerateEmbeddingParams)
])
const chunkData = fs.readFileSync(chunkTmp)
fs.unlinkSync(chunkTmp)
try {
const embVec = await generateMultimodalEmbedding(ai, chunkData, 'video/mp4')
@@ -169,9 +172,11 @@ export async function generateEmbeddingActivity(params: GenerateEmbeddingParams)
`failed to generate video embedding for chunk ${start}-${end}: ${e.message}`,
)
}
} finally {
if (fs.existsSync(chunkTmp)) {
fs.unlinkSync(chunkTmp)
}
}
} finally {
fs.unlinkSync(tmpFile)
}
}
@@ -233,7 +238,7 @@ export async function generateTextEmbeddingActivity(params: GenerateTextEmbeddin
export interface ExtractAiMetadataParams {
assetKey: string
filePath: string
filePath?: string
type: 'autofill'
isImage: boolean
}
@@ -246,7 +251,12 @@ export async function extractAiMetadataActivity(
const aiDir = path.join(assetDir, 'ai_metadata')
const generatedFiles: string[] = []
const tmpDir = path.dirname(params.filePath)
let tmpDir = params.filePath ? path.dirname(params.filePath) : ''
let cleanupTmp = false
if (!tmpDir) {
tmpDir = transcodeService.createTempDir('ai-meta-')
cleanupTmp = true
}
try {
if (params.type === 'autofill') {
@@ -259,8 +269,10 @@ export async function extractAiMetadataActivity(
// Not found
}
const inputSource = params.filePath || (await s3Service.resolveInput(bucket, params.assetKey))
const files = await transcodeService.extractVideoFrames({
inputFile: params.filePath,
inputFile: inputSource,
outputDir: tmpDir,
numFrames: 30,
frameHeight: 720,
@@ -276,7 +288,9 @@ export async function extractAiMetadataActivity(
}
}
} finally {
// Files are in tmpDir which will be cleaned up by cleanupTmpDirActivity
if (cleanupTmp && tmpDir) {
transcodeService.removeDir(tmpDir)
}
}
return generatedFiles
@@ -0,0 +1,324 @@
import { describe, it, expect, vi, beforeEach } from 'vitest'
import { sandboxService } from '@shumai/core'
import type { SandboxProvider, SandboxConfig, WrapCommandOptions } from '@shumai/core'
import { createAgentSession, type DbProviderInfo } from './index'
import { createSandboxedBashTool } from './tools/sandboxed-bash'
import { prisma } from '@shumai/db'
import { setupTestDbHooks } from '@shumai/db/test'
import { spawn } from 'node:child_process'
import { EventEmitter } from 'node:events'
vi.mock('node:child_process')
class TestSandboxProvider implements SandboxProvider {
initialized = false
config: SandboxConfig | null = null
initializeCalls = 0
updateConfigCalls = 0
resetCalls = 0
wrapCommandCalls: Array<{ command: string; options?: WrapCommandOptions }> = []
violationsByCommandId = new Map<string, string>()
async initialize(config: SandboxConfig): Promise<void> {
this.initialized = true
this.config = config
this.initializeCalls++
}
async wrapCommand(command: string, options?: WrapCommandOptions): Promise<string> {
this.wrapCommandCalls.push({ command, options })
return `sandboxed-${command}`
}
async updateConfig(config: Partial<SandboxConfig>): Promise<void> {
this.updateConfigCalls++
if (this.config && config.network) {
this.config.network = { ...this.config.network, ...config.network }
}
}
async reset(): Promise<void> {
this.resetCalls++
this.initialized = false
this.config = null
}
isInitialized(): boolean {
return this.initialized
}
getBlockedHostForCommand(commandId: string): string | null {
return this.violationsByCommandId.get(commandId) ?? null
}
}
const mockProviders: DbProviderInfo[] = [
{
name: 'google',
config: { api: 'google-generative-ai', apiKey: 'GOOGLE_API_KEY' },
models: [
{
modelId: 'gemini',
name: 'Gemini',
config: {
api: 'google-generative-ai',
reasoning: false,
input: ['text'],
cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
contextWindow: 8192,
maxTokens: 4096,
},
},
],
},
]
describe('Concurrent Sandbox Sessions', () => {
setupTestDbHooks()
let testProvider: TestSandboxProvider
beforeEach(async () => {
vi.clearAllMocks()
testProvider = new TestSandboxProvider()
sandboxService.setProvider(testProvider)
})
it('does not reset sandbox when new sessions start while a command is running', async () => {
const team = await prisma.team.create({
data: { name: 'Concurrent Test Team' },
})
await prisma.sandbox.create({
data: {
teamId: team.id,
networkSandboxEnabled: true,
allowedDomains: ['api.github.com'],
},
})
await prisma.user.create({
data: {
id: 'agent-1',
name: 'Agent User',
email: 'agent-user@shumai.ai',
type: 'agent',
},
})
await prisma.agent.create({
data: {
id: 'agent-1',
teamId: team.id,
type: 'chat',
config: { provider: 'google', model: 'gemini' },
},
})
// 1. Session A starts and syncs domains
await createAgentSession({
teamId: team.id,
agentId: 'agent-1',
providerName: 'google',
modelId: 'gemini',
systemPrompt: 'Session A prompt',
teamSkills: [],
allowedDomains: ['api.github.com'],
providers: mockProviders,
})
expect(testProvider.initializeCalls).toBe(1)
expect(testProvider.resetCalls).toBe(0)
// 2. Session A runs a bash command that takes time
const tool = createSandboxedBashTool('/mock/cwd')
const mockStdout = new EventEmitter()
const mockStderr = new EventEmitter()
const mockChild = Object.assign(new EventEmitter(), {
stdout: mockStdout,
stderr: mockStderr,
pid: 999,
kill: vi.fn(),
})
// eslint-disable-next-line @typescript-eslint/no-explicit-any -- mock spawn return value
;(spawn as any).mockReturnValue(mockChild)
const sessionExecutionA = tool.execute('call-session-a-1', {
command: 'curl https://api.github.com/repos',
source: 'skill',
})
// 3. Concurrently, Session B starts with additional allowed domains
await createAgentSession({
teamId: team.id,
agentId: 'agent-1',
providerName: 'google',
modelId: 'gemini',
systemPrompt: 'Session B prompt',
teamSkills: [],
allowedDomains: ['api.github.com', 'pypi.org'],
providers: mockProviders,
})
// Assert sandbox was hot-reloaded without any reset!
expect(testProvider.resetCalls).toBe(0)
expect(testProvider.updateConfigCalls).toBe(1)
expect(sandboxService.getCurrentAllowedDomains()).toEqual(['api.github.com', 'pypi.org'])
// 4. Concurrently, Session C starts with the same domains (should be no-op, no reset, no updateConfig)
await createAgentSession({
teamId: team.id,
agentId: 'agent-1',
providerName: 'google',
modelId: 'gemini',
systemPrompt: 'Session C prompt',
teamSkills: [],
allowedDomains: ['pypi.org', 'api.github.com'],
providers: mockProviders,
})
expect(testProvider.resetCalls).toBe(0)
expect(testProvider.updateConfigCalls).toBe(1) // Still 1, no duplicate update
// 5. Session A's command completes successfully
mockStdout.emit('data', Buffer.from('{"status":"ok"}'))
mockChild.emit('close', 0)
const result = await sessionExecutionA
expect(result.details).toEqual(
expect.objectContaining({
exitCode: 0,
}),
)
// Verify command was wrapped with options containing commandId: 'call-session-a-1'
expect(testProvider.wrapCommandCalls).toContainEqual({
command: 'curl https://api.github.com/repos',
options: { commandId: 'call-session-a-1' },
})
})
it('isolates blocked host violations per commandId during concurrent execution', async () => {
await sandboxService.ensureInitialized({ allowedDomains: ['api.github.com'] })
// Command 1 and Command 2 run concurrently
await sandboxService.wrapCommand('curl http://blocked1.com', { commandId: 'cmd-1' })
await sandboxService.wrapCommand('curl http://blocked2.com', { commandId: 'cmd-2' })
testProvider.violationsByCommandId.set('cmd-1', 'blocked1.com')
testProvider.violationsByCommandId.set('cmd-2', 'blocked2.com')
// Blocked hosts should be accurately isolated
expect(sandboxService.getBlockedHost('cmd-1')).toBe('blocked1.com')
expect(sandboxService.getBlockedHost('cmd-2')).toBe('blocked2.com')
expect(sandboxService.getBlockedHost('cmd-unknown')).toBe('')
})
it('does not reject concurrent allowed command when another command is blocked', async () => {
await sandboxService.ensureInitialized({ allowedDomains: ['api.github.com'] })
const tool = createSandboxedBashTool('/mock/cwd', undefined, {
getBlockedHost: (commandId?: string) => sandboxService.getBlockedHost(commandId),
clearBlockedHost: () => sandboxService.clearBlockedHost(),
})
const childBlocked = Object.assign(new EventEmitter(), {
stdout: new EventEmitter(),
stderr: new EventEmitter(),
pid: 101,
kill: vi.fn(),
})
const childAllowed = Object.assign(new EventEmitter(), {
stdout: new EventEmitter(),
stderr: new EventEmitter(),
pid: 102,
kill: vi.fn(),
})
let spawnIndex = 0
// eslint-disable-next-line @typescript-eslint/no-explicit-any -- mock spawn implementation
;(spawn as any).mockImplementation(() => {
spawnIndex++
return spawnIndex === 1 ? childBlocked : childAllowed
})
// Record violation for the blocked command only
testProvider.violationsByCommandId.set('call-blocked', 'blocked-target.com')
const blockedExecution = tool.execute('call-blocked', {
command: 'curl http://blocked-target.com',
source: 'skill',
})
const allowedExecution = tool.execute('call-allowed', {
command: 'curl https://api.github.com/data',
source: 'skill',
})
await vi.waitFor(() => expect(spawn).toHaveBeenCalledTimes(2))
childBlocked.stdout.emit('data', Buffer.from('blocked output'))
childBlocked.emit('close', 0)
childAllowed.stdout.emit('data', Buffer.from('allowed output'))
childAllowed.emit('close', 0)
await expect(blockedExecution).rejects.toThrow(
'Network request to blocked-target.com is blocked',
)
const allowedResult = await allowedExecution
expect(allowedResult.details).toEqual(expect.objectContaining({ exitCode: 0 }))
})
it('does not synchronize or overwrite sandbox allowlist when allowedDomains is omitted (e.g. naming sessions)', async () => {
const team = await prisma.team.create({
data: { name: 'Omitted Domains Team' },
})
await prisma.user.create({
data: {
id: 'agent-omitted',
name: 'Agent User',
email: 'agent-omitted@shumai.ai',
type: 'agent',
},
})
await prisma.agent.create({
data: {
id: 'agent-omitted',
teamId: team.id,
type: 'chat',
config: { provider: 'google', model: 'gemini' },
},
})
// 1. First session sets allowedDomains to ['*.github.com']
await createAgentSession({
teamId: team.id,
agentId: 'agent-omitted',
providerName: 'google',
modelId: 'gemini',
systemPrompt: 'Main prompt',
teamSkills: [],
allowedDomains: ['*.github.com'],
providers: mockProviders,
})
expect(sandboxService.getCurrentAllowedDomains()).toEqual(['*.github.com'])
const updateCallsBefore = testProvider.updateConfigCalls
// 2. Utility / naming session runs WITHOUT allowedDomains
await createAgentSession({
teamId: team.id,
agentId: 'agent-omitted',
providerName: 'google',
modelId: 'gemini',
systemPrompt: 'Title generator',
teamSkills: [],
// allowedDomains omitted
disableTools: true,
providers: mockProviders,
})
// Assert sandbox was NOT touched or overwritten
expect(testProvider.updateConfigCalls).toBe(updateCallsBefore)
expect(sandboxService.getCurrentAllowedDomains()).toEqual(['*.github.com'])
})
})
@@ -0,0 +1,354 @@
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 context with user and thread tag with reply_count', () => {
const context: ShumaiMessageContext = {
user: { id: 'usr_1', name: 'Alice', role: 'editor' },
thread: { id: 'th_01JXYZ', replyCount: 3 },
}
expect(serializeContextToXml(context)).toBe(
'<context>\n <user id="usr_1" name="Alice" role="editor" />\n <thread id="th_01JXYZ" reply_count="3" />\n</context>',
)
})
it('serializes context with thread tag without reply_count', () => {
const context: ShumaiMessageContext = {
thread: { id: 'th_01JXYZ' },
}
expect(serializeContextToXml(context)).toBe(
'<context>\n <thread id="th_01JXYZ" />\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.2500" />
<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 precision (toFixed(4) for position, toFixed(2) for duration)', () => {
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.5000"')
expect(serializeContextToXml(context2)).toContain('duration_seconds="14.00"')
expect(serializeContextToXml(context2)).toContain('seconds="5.5000"')
})
it('serializes annotation tag with id when context.id is provided', () => {
const context: ShumaiMessageContext = {
id: '01JABCDEF1234567890',
annotation: true,
}
expect(serializeContextToXml(context)).toBe(
'<context>\n <annotation id="01JABCDEF1234567890" />\n</context>',
)
})
it('escapes special XML characters in annotation id', () => {
const context: ShumaiMessageContext = {
id: 'test<id>&"123"',
annotation: true,
}
expect(serializeContextToXml(context)).toBe(
'<context>\n <annotation id="test&lt;id&gt;&amp;&quot;123&quot;" />\n</context>',
)
})
})
})

Some files were not shown because too many files have changed in this diff Show More