Compare commits

...
32 Commits
Author SHA1 Message Date
yiling 96493a5493 Release v0.3.6 2026-08-12 14:56:54 +08:00
Yiling-J 93c593545d fix(i18n): update Chinese translation for dashboard to 仪表板 (#301) 2026-08-12 14:46:46 +08:00
Yiling-J 11758c23c0 docs(mcp): add MCP support documentation to README and docs (#300)
* docs(mcp): add MCP support documentation

* docs(readme): simplify MCP feature description

* docs(mcp): fix inaccuracies in MCP servers documentation

- Clarify that discovery runs on refresh, OAuth completion, or first
  tool call, not automatically at server creation
- Note that advanced settings (transport, auth, permission, direct
  tools) are configured in the edit dialog after creation
- Correct agent assignment UI description: switch toggle, not checkbox

* docs(mcp): explain proxy vs direct tool configuration

Add a dedicated section covering the three tool states (Off / Proxy /
Direct), what the mcp proxy tool does and why it exists, and when and
why to use direct tools, including the context-token trade-off.
2026-08-12 14:26:10 +08:00
Yiling-J 1cd94a77c6 feat(webui): direct canvas PDF rendering with selectable text (#299)
* feat(webui): render pdf pages via live canvas with selectable text

Replace the rasterize-to-PNG pipeline in the PDF viewer with direct
canvas rendering that tracks the current zoom, so text stays crisp when
zoomed in, and overlay a pdf.js TextLayer that makes text natively
selectable when not in draw mode.

- pdf-viewer: render pages onto a live canvas at a zoom-proportional
  scale (debounced, memory-capped) instead of a fixed 2x PNG snapshot
- pdf-viewer: add pdf.js TextLayer overlay per page, transformed in
  lockstep with the Konva stage so spans stay aligned while panning
  and zooming
- drawing-canvas: accept an optional live canvas element and force a
  layer redraw when it is swapped
- add text-layer.css with the minimal pdf.js text layer styles
- add e2e spec verifying text selection in view mode and that draw
  mode routes drags to the canvas

* fix(webui): show pdf text selection highlight above the page canvas

The pdf.js text layer was stacked below the opaque Konva page canvas, so
the native selection highlight was painted underneath it and invisible
(selection itself worked). Move the overlay above the canvas and gate its
pointer-events on draw mode: auto when not drawing (select text), none in
draw mode so drags reach the Konva stage below (draw markup).

Verified with screenshot pixel analysis: the selected region now renders
the highlight (blue) where it was pure grayscale before.

* fix(webui): transparent selection background for pdf text layer br elements

* fix(webui): stop pdf text selection over-selecting in empty space

The text layer container was user-selectable (user-select: auto), so when
a drag's caret moved into empty space Chromium targeted the container and
extended the selection to a container-content boundary, selecting across
rows (e.g. dragging from line 1 into the gap selected lines 1-2).

Make the container user-select: none while keeping the text spans
user-select: text, so the caret clamps to the nearest selectable text and
the selection stays put when dragging into empty space.

* fix(webui): deselect pdf text when clicking empty space

With user-select: none on the text layer container, Chromium no longer
clears the selection when clicking non-selectable areas. Clear it manually
on mousedown over the container or <br> (not a text span) so clicking
empty space between lines or outside text deselects, matching native
behavior.
2026-08-12 13:58:02 +08:00
Yiling-J 5ad3fdbf69 fix(webui): content-only pinch-zoom and two-finger pan in media viewers (#298)
* fix(webui): add content-only pinch-zoom and two-finger pan to media viewers

Intercept trackpad pinch (ctrl+wheel), touchscreen pinch (two touches),
and two-finger move inside the image, video, and PDF viewers so they
transform only the media content instead of triggering browser page
zoom (matching Frame.io behavior).

- New shared pan-zoom math (zoomAtPoint, fitScale, isZoomed) and a
  usePanZoomGestures hook using native non-passive wheel/touch listeners
  with touch-action: none on the media container.
- Plain wheel / two-finger scroll pans the content, but only once the
  user has zoomed in; drag-pan is gated the same way.
- Image and PDF viewers no longer reset zoom to fit on container resizes
  while the user has manually zoomed (matches the video viewer).
- DrawingCanvas ignores multi-touch moves so single-pointer pan/draw
  doesn't fight the pinch handler; the video viewer keeps play/pause on
  the container div to avoid double-toggling when the overlay is active.

Includes unit tests for the pan-zoom math.

* fix(webui): disable click-drag pan for pdf and video viewers

When zoomed, PDF and video previously panned on left-button (or
single-finger touch) drag via the shared DrawingCanvas. That conflicts
with left-click semantics: PDF wants the drag for text selection and
video reserves the click for play/pause.

Remove the gated onPan from both viewers so the Konva overlay stays
pointer-events:none when not drawing - clicks pass straight through
(video click-to-play now works cleanly at any zoom) - while panning
remains available via mouse wheel and two-finger gestures. Image keeps
drag-pan.
2026-08-12 10:54:42 +08:00
Yiling-J 851ae49c84 feat(mcp): support tool-level directTools array and 3-state UI configuration (#297)
* feat(mcp): support tool-level directTools array and 3-state UI configuration

* refactor(mcp): refine tool hint explanation and separate server instructions block

* style(mcp): display tool count in header title and split option hints into 3 lines

* style(mcp): update tools description paragraph and place bulk buttons on a separate row

* fix(mcp): enforce excludeTools in proxy path and align direct-tool counts

- Filter the per-agent tool registry by excludeTools at build time (DB cache
  and lazy-connect paths), so excluded tools are unreachable through the mcp
  proxy (call, search, list, describe) — matching pi-mcp-adapter where
  isToolAllowed gates both direct and gateway exposure.
- Add shared isDirectTool predicate (matches original or prefixed name) used
  by both buildDirectTools and the proxy description counts, so the
  advertised direct/proxy counts can no longer drift from actual
  registration; toolCount now reflects allowed tools only.
- Remove the legacy boolean directTools branch (no legacy data exists).
- Drop the now-unused mcp_excluded_tools_hint i18n key and regenerate
  Paraglide messages.
- Extend unit tests: excluded tools are not counted, listed, searched, or
  callable via the proxy; prefixed-name directTools configs count correctly.
2026-08-11 15:43:27 +08:00
Yiling-J 82aee9a291 fix(agent): resolve version stack name and size in list_assets (#296)
* fix(agent): resolve version stack name and size in list_assets

* fix(agent): resolve version stack to latest version in download_asset, analyze_image, and read_pdf_pages
2026-08-11 12:09:29 +08:00
Yiling-J 1b5cbf936a feat(mcp): add MCP server support with proxy tool and OAuth flow (#289)
* feat(mcp): add MCP server support with proxy tool and OAuth flow

Add URL-based MCP (Model Context Protocol) server support to the backend:

- DB: McpServer / AgentMcpServer / McpServerCredential models with
  typed JSON columns (auth config, cached tools, stored OAuth tokens,
  pending auth state) and a migration.
- Core (@shumai/core/src/mcp): DB-backed credential store, OAuth
  client provider (authorization_code + client_credentials) with a
  Hono-hosted redirect callback, connection lifecycle manager
  (Streamable HTTP with SSE fallback, lazy connect, 401 -> needs_auth),
  JSON Schema -> AgentTool parameter conversion, in-memory tool registry
  with ranked search, the single 'mcp' proxy AgentTool (search /
  describe / list / call / connect / status / auth-start), per-server
  opt-in direct tools ({server}_{tool}), and McpService (CRUD,
  discovery, OAuth, per-agent assignment via AgentMcpServer, and
  permission gating on tool execution mirroring skills).
- Agent: chat agents receive the 'mcp' proxy tool (plus direct tools
  for opted-in servers) built from their assigned, enabled servers.
- API: /teams/:teamId/mcp/servers CRUD, tools refresh/list, auth
  start/complete/status/remove, test, permission, and the public
  OAuth callback route; Admin authz via new ResourceType.McpServer;
  audit logging.
- DTOs: zod schemas + types for servers, tools, auth, and per-agent
  mcpServerIds.
- Tests: DB store, schema conversion, registry/search, service
  integration against a real in-process MCP server (v2
  @modelcontextprotocol/server), permission gating, rename
  invalidation, direct tools, per-agent assignment, API route tests,
  and workflow E2E (local + temporal) for proxy and direct modes.

* fix(mcp): persist OAuth discovery snapshot and stamp SEP-2352 issuer

The callback leg of the OAuth flow failed with
AuthorizationServerMismatchError ('discoveryState was not available on
the callback leg') because McpDbStore.savePendingAuth overwrote the
entire pendingAuth JSON column, clobbering the discoverySnapshot that
the provider's saveDiscoveryState() had stored inside it.

- McpDbStore.savePendingAuth now preserves an in-flight discovery
  snapshot so the callback leg can satisfy the SEP-2352 authorization-
  server issuer check.
- McpOauthProvider now round-trips the issuer stamp derived from the
  discovery snapshot: saveClientInformation/saveTokens persist it,
  clientInformation()/tokens() return it, and tokens() backfills a
  missing stamp for pre-existing credentials (removes the
  'stored OAuth credential has no issuer stamp' warning).
- Regression tests: savePendingAuth keeps the snapshot; the provider
  stamps/round-trips the issuer on both legs.

* fix(mcp): backfill SEP-2352 issuer stamp on stale OAuth client info

clientInformation() returned stored client info without an issuer field
when it had been dynamically registered before the stamping fix, so the
SDK logged 'stored OAuth credential has no issuer stamp' on every read.
Now the stored branch backfills the issuer from the discovery snapshot
(persisting it) exactly like the tokens() backfill.

* feat(webui): add MCP server configuration and agent assignment UI (#290)

* feat(webui): add MCP server configuration and agent assignment UI

* fix(webui): auto-detect auth for unconfigured MCP servers and show connect button

* fix(mcp): auto-generate state in mcp-oauth-provider when missing in DB

* fix(mcp): persist OAuth discovery snapshot and stamp SEP-2352 issuer

The callback leg of the OAuth flow failed with
AuthorizationServerMismatchError ('discoveryState was not available on
the callback leg') because McpDbStore.savePendingAuth overwrote the
entire pendingAuth JSON column, clobbering the discoverySnapshot that
the provider's saveDiscoveryState() had stored inside it.

- McpDbStore.savePendingAuth now preserves an in-flight discovery
  snapshot so the callback leg can satisfy the SEP-2352 authorization-
  server issuer check.
- McpOauthProvider now round-trips the issuer stamp derived from the
  discovery snapshot: saveClientInformation/saveTokens persist it,
  clientInformation()/tokens() return it, and tokens() backfills a
  missing stamp for pre-existing credentials (removes the
  'stored OAuth credential has no issuer stamp' warning).
- Regression tests: savePendingAuth keeps the snapshot; the provider
  stamps/round-trips the issuer on both legs.

* fix(mcp): backfill SEP-2352 issuer stamp on stale OAuth client info

clientInformation() returned stored client info without an issuer field
when it had been dynamically registered before the stamping fix, so the
SDK logged 'stored OAuth credential has no issuer stamp' on every read.
Now the stored branch backfills the issuer from the discovery snapshot
(persisting it) exactly like the tokens() backfill.

* fix(mcp): attach McpOauthProvider for auto-detected OAuth servers and discover tools on auth completion

* fix(webui): fix flex min-h-0 and max-h scrolling on MCP tools dialog

* fix(webui): set explicit flex height on McpToolsDialog for active scrolling

* feat(webui): make MCP server cards clickable to edit and widen server config dialog

* feat(mcp): agent-level server enablement and auto-detected server metadata (#291)

* feat(mcp): agent-level server enablement and auto-detected server metadata

- Remove the server-level `enabled` column from mcp_servers; enable/disable
  now happens per-agent via the AgentMcpServer join table (mirrors skills).
- Drop the unique (teamId, name) constraint so duplicate server names are allowed.
- Add a `description` column, auto-filled from client.getServerVersion() on
  connect; the server name is auto-filled from the reported title (fallback name)
  with a URL-derived placeholder until first connect.
- Remove manual name input: the create dialog is URL-only, and the edit dialog
  shows the auto-detected name/description read-only.
- Replace the include/exclude raw-text inputs with the tool list in the edit
  dialog, managing only excludeTools; remove includeTools support and the
  separate McpToolsDialog component.
- Sanitize server-reported names into safe direct-tool prefixes (spaces/punctuation
  become underscores) and use the same sanitization in the proxy resolver.

* fix(mcp): give the edit-dialog tool list a definite height

The Shadcn ScrollArea viewport is h-full, which requires a definite height
on the root. Using max-h-64 left the viewport at auto height, so the root
clipped the list at 256px without engaging its own scrollbar — tools past
the cutoff were unreachable. Use a fixed h-64 container (same pattern as
move-copy-dialog) so the inner scroll area scrolls independently of the
dialog's outer scroll.

* refactor(mcp): fixed header/footer with scrollable content in server config dialog

Mirror the skill config dialog layout: the edit dialog now keeps the header
and footer fixed and scrolls only the content area (ScrollArea flex-1
min-h-0 inside an h-[85vh] flex column). The tools list no longer has its
own nested ScrollArea — it flows inside the content-level scroll, so all
tools are reachable without a nested-scroll conflict. The create dialog
stays compact (URL-only) like the skill add dialog.

Verified headlessly that max-height-based ScrollArea roots do not engage
scrolling (viewport height resolves to auto), which is why the previous
nested list clipped; the flex-based definite-height pattern scrolls.

* feat(mcp): make the endpoint URL immutable after creation

Editing a server's URL effectively points it at a different server, and the
create flow is URL-only anyway — so the edit dialog no longer allows changing
it (delete + re-add covers endpoint changes). The URL is displayed read-only
next to the auto-detected name/description, and `url` was removed from the
update DTO and service; auth/transport changes still invalidate credentials
and cached tools.

* refactor(mcp): match MCP server cards to the skill card layout

The settings list cards now share the skill card structure: row 1 is the
server name (with direct-mode/transport badges) plus the three-dot menu,
row 2 is the description (falling back to 'No description provided') with
the endpoint URL and last error as small mono lines, and row 3 holds the
connection-status badge and updated date on the left with the permission
selector and the connect button at the right end.

* fix(mcp): stop card menu clicks from opening the edit dialog

The three-dot menu is portaled, so its item clicks bubble through React's
synthetic events to the card's onClick, which opened the edit dialog before
the delete confirmation appeared. Add e.stopPropagation() to every menu
item (matching the skill card pattern).

* fix(mcp): stop Refresh Tools from submitting/closing the config dialog

The Refresh Tools button lived inside the <form> and, like all buttons
without an explicit type, defaulted to type="submit" — clicking it ran the
form submit (save + close) instead of just refreshing. Set type="button".

Also per UX: while refreshing, the button is disabled with a spinning icon,
the per-tool enable/disable switches are disabled, and the success toast is
removed — the button reverting to its idle state is the success signal
(keep the error toast for failures).

* test(mcp): provide explicit redirectUri in McpOauthProvider test helper

* fix(mcp): scope tool registry to agent-assigned servers

The MCP tool registry was a process-global singleton keyed by server id,
so a chat agent could search, describe, and even call tools belonging to
MCP servers that were not assigned to it (e.g. disabled or unassigned
servers), as long as their metadata had been discovered at some point in
the process. This mirrors the disabled-skill bug: the read path never
checked per-agent enablement.

Replace the singleton with a fresh McpToolRegistry built per
buildAgentTools call and warmed from the persisted McpServer.tools DB
cache. Because the registry only ever contains the agent's assigned
servers, unassigned/disabled servers can neither be suggested, searched,
described, nor executed. Live discovery (lazy connect / connect action)
writes into the per-agent registry via ensureConnected(serverId,
registry?).

Adds test-first coverage: suggestions, search, describe and tool-call
leaks across an unassigned same-team server, staleness after
unassignment, and direct-tools scoping.

* feat(mcp): capture and surface server instructions + server-level refresh (#293)

* feat(mcp): capture and surface server instructions

- Add McpServer.instructions column, populated from getInstructions() at
  connect time (legacy initialize + modern discover results)
- Surface instructions at three levels like pi-mcp-adapter: truncated
  snippet in the mcp proxy tool description, preview in server listings,
  and full text via mcp({ instructions: "name" })
- Fix misleading mcp({ server, connect }) usage line to mcp({ connect })
- Share one renderServerListing helper across list and connect modes
- Expose instructions in McpServerInfo DTO and WebUI config card
- Test server supports instructions; service + API tests updated

* refactor(mcp): server-level refresh endpoint, drop agent connect mode

- Replace POST /mcp/servers/:id/tools/refresh with POST /mcp/servers/:id/refresh
  returning the refreshed McpServerInfo (server-level, not tools-level)
- Add McpService.refreshServer(): force-close the connection, re-discover and
  persist tools, instructions, name/description and status; used by the refresh
  endpoint, Test Connection, and post-OAuth completion (replacing discoverTools)
- Remove discoverTools entirely - refreshServer is the single discovery entry
  point (testServer and completeAuth route through it)
- Remove refreshTools from UpdateMcpServerRequest/PATCH (dead param)
- Remove mcp({ connect: "name" }) from the agent proxy tool: lazy tool calls
  still auto-connect, so agents are unaffected
- WebUI: remove the dialog 'Refresh Tools' button and create-mode background
  auto-refresh; add a server-level Refresh button at the left end of the edit
  dialog footer; i18n mcp_refresh_server (+ success message)

* feat(mcp): add in-flight request tracking and idle connection cleanup (#294)

* feat(mcp): add in-flight request tracking and idle connection cleanup

* feat(mcp): add background idle cleanup timer to McpService

* feat(mcp): update default background idle cleanup check interval to 30s

* feat(webui): improve MCP server card footer, instructions, and refresh dialog freeze (#295)

* feat(webui): improve MCP server list card, instructions dialog, and refresh freeze UI

* feat(webui): refine MCP card action menu items

* docs(webui): update direct tools mode description in i18n messages

* style(webui): refine Direct Tools Mode layout in MCP server config dialog

* feat(webui): remove tool search box from MCP server config dialog

* fix(mcp): make in-flight idle tracking test deterministic

The 'tracks in-flight requests and safely prunes idle connections' test
relied on a wall-clock sleep (10ms) to guess when the tool handler had
started executing on the server. On slow/loaded CI runners the HTTP round
trip through the real MCP client/server stack can exceed that window, so
resolveSlowTool() fired the no-op placeholder, the gated handler never
completed, and callPromise hung until the 5000ms test timeout.

The handler now signals via a deferred promise when it actually starts,
and the test awaits that signal (racing it against the call promise to
surface early failures) before asserting in-flight state and releasing
the gate. Also gives the test an explicit 10s timeout.
2026-08-11 11:01:38 +08:00
Yiling-J 1daeaf51ef fix(agent): prevent agents from accessing disabled skills (#292)
Disabling a skill in the agent config dialog only removed it from the
agent_skills join table, but the chat flow still advertised ALL team
skills to the model in the <available_skills> system prompt section and
the read_skill tool never checked per-agent enablement.

- getAgentChatContextActivity / getAgentAutofillContextActivity now only
  return skills explicitly enabled for the agent (agent_skills), and
  expose enabledSkillIds in the execution context.
- createReadSkillTool accepts enabledSkillIds and rejects read_skill
  calls for skills not enabled for the agent, even if the model knows
  the skill id from earlier conversation history.
- Added unit tests for context filtering (chat + autofill), tool-level
  enforcement, and the zero-enabled-skills case.
2026-08-10 17:33:40 +08:00
yiling 49ef48a74a Release v0.3.5 2026-08-09 20:58:35 +08:00
Yiling-J a680fccb12 fix(webui): enable rename and delete actions in file detail top bar breadcrumb (#288)
* fix(webui): enable rename and delete actions in file detail top bar breadcrumb

* fix(webui): select only base file name when renaming from file detail breadcrumb
2026-08-09 20:49:55 +08:00
Yiling-J e67552d8bd fix(webui): batch download no longer flashes a tab per file (#287)
startDownload() used <a target="_blank" download> anchors, which made
Chrome open a new tab for every file that then auto-closed as soon as the
download started (Content-Disposition: attachment). Replace with hidden
iframes: downloads start in the background without opening tabs, and a
failed/expired link renders inside the hidden iframe instead of
navigating the SPA tab away.
2026-08-09 17:09:01 +08:00
Yiling-J 8080acfb2e fix: use renamed asset name in download Content-Disposition (#286)
* fix(core): use renamed asset name in download Content-Disposition

Downloads of renamed assets (e.g. test.png renamed to foo.png) previously
saved under the storage-key basename because the presigned URLs / local
file handler only set Content-Disposition: attachment without a filename,
and the HTML download attribute is ignored for cross-origin URLs.

- Add buildContentDisposition() helper that emits a sanitized
  'attachment; filename=...; filename*=UTF-8...' header (RFC 5987) so
  non-ASCII names survive.
- Thread an optional filename through S3Service.presign():
  * S3 backend passes it via contentDisposition (response-content-disposition)
  * Local backend carries it as a ?filename= query param consumed by the
    /files serveStatic onFound handler
- getDownloadLinks / getDownloadUrl now pass the renamed asset name from
  the DB, so all download flows (file browser, viewers, breadcrumb, share)
  save files under the current asset name.

* fix(core): keep Content-Disposition header ASCII for non-ASCII names

Bun's Headers API rejects header values containing non-ASCII bytes, so a
download of a renamed file with a non-ASCII name (e.g. 幻境边界.pptx) threw
'TypeError: Header Content-Disposition has invalid value' on the local
storage backend.

Per RFC 5987, non-ASCII names belong only in the percent-encoded
filename* parameter. buildContentDisposition now emits the quoted
filename="..." fallback only when the name is pure ASCII; otherwise the
header carries just 'attachment; filename*=UTF-8''...' (all-ASCII, accepted
by Bun/Node Headers and all modern browsers).
2026-08-09 16:39:15 +08:00
Yiling-J dbd30a815f fix(webui): exclude file extension when selecting file name during inline rename (#285) 2026-08-09 16:06:44 +08:00
Yiling-J 442568de00 fix(webui): resolve upload card freeze for unsupported files (#284) 2026-08-09 15:16:41 +08:00
yiling d15fc5c6be update doc 2026-08-09 14:49:07 +08:00
Yiling-J aa6d5ed626 feat(transcode): add Gotenberg support for Office, HTML, CSV, and Markdown PDF proxies (#283)
* feat(transcode): add Gotenberg support for Office, HTML, CSV, and Markdown PDF proxies

* fix(transcode): use Gotenberg chromium markdown endpoint with index.html wrapper for markdown conversion

* test(transcode): add complete unit test coverage for HTML, CSV landscape/portrait, TXT, and Gotenberg fallback branches

* fix(gotenberg): force .md extension for Gotenberg markdown conversion endpoint compatibility

* refactor(gotenberg): standardize basic auth environment variables on GOTENBERG_BASIC_AUTH_USERNAME and GOTENBERG_BASIC_AUTH_PASSWORD

* test(e2e): add real Gotenberg testcontainers workflow E2E test for docx, pptx, and xlsx

* docs: add Gotenberg document PDF conversion documentation and update features in README

* docs(gotenberg): add Docker quickstart commands and remove obsolete GOTENBERG_USERNAME note
2026-08-09 14:44:13 +08:00
yiling 283d28bed9 Release v0.3.4 2026-08-08 20:15:25 +08:00
Yiling-J 315cacd474 Enhance README with new features and capabilities
Added new features including customizable watermark for shared links and support for various file formats.
2026-08-08 16:25:48 +08:00
Yiling-J 44ab1e7023 Add wide file format support to README 2026-08-08 16:19:09 +08:00
yiling beef4e9963 update readme 2026-08-08 16:06:25 +08:00
Yiling-J 990f68fb3b docs(agent): clarify create_file/create_version context param guidance (#282) 2026-08-08 15:41:22 +08:00
Yiling-J ee4933a4f8 feat(transcode): update preview thumbnail resolution to 300p with max length constraint (#281)
* feat(transcode): update preview thumbnail resolution to 300p with max length constraint

* fix(transcode): address code review feedback on preview thumbnail transcoding
2026-08-08 15:17:51 +08:00
Yiling-J c91867b8eb chore: split e2e scripts into app and webui targets (#280)
Split the monolithic test:e2e script into:

- test:e2e:app: fullstack web app e2e (playwright --project=app-chromium)
- test:e2e:webui: harness UI integration tests
  (E2E_SKIP_APP_SERVER=true --project=harness-chromium)

Remove the now-unused test:e2e:ui and test:e2e:report scripts, and update
the AGENTS.md submission rules and e2e README to reference the new
commands.
2026-08-08 13:20:52 +08:00
Yiling-J 8608ee027a test(e2e): stabilize watermark share spec on Firefox (#279)
Two issues made the watermarked share-link spec flaky on Firefox (and
silently mis-typed on every browser):

1. test.use inside a for loop leaks the last iteration's value to all
   tests: both the 'image' and 'video' cases were actually running the
   video flow. Scope each test.use inside a test.describe block.

2. Selecting the file by clicking the card body raced with the preview
   area re-rendering (video sprite scrubber hover) and the Radix menu
   exit animation, which could swallow the click on Firefox. Select via
   the card checkbox instead, and wait for the menu to fully unmount
   after Escape before the next interaction.

Verified stable: 6/6 on Firefox, 2/2 on Chromium, 2/2 on WebKit.
2026-08-08 13:11:44 +08:00
Yiling-J 394ddc8db4 docs(share-links): document allow download and lazy watermark settings (#278)
Document the two new share link security settings:

- Allow Download: hides all download affordances on the public pages and
  rejects the download endpoint with 403 while keeping previews available.
- Watermark: per-share-link lazy watermarking — transcodes are only
  triggered when the watermark is enabled on a share link (and again for
  files added later), so Shumai never stores watermark copies for files
  that are not shared through a watermarked link, saving storage.
2026-08-08 11:51:39 +08:00
Yiling-J 83455aeaea test(e2e): cover watermarked download-disabled share links for image and video (#277)
Add web app e2e coverage for the frequently-combined watermark +
download-disabled share link configuration. For both watermarkable media
types (image and video) the test asserts:

- no download affordance on the public share list page (card menu,
  selection bar) and the public file detail page (viewer control bar,
  top-nav file dropdown; video also has no resolution submenu)
- the proxy loaded in the detail page is the watermarked version
  (-watermark- S3 keys) and no original transcode key is requested
- the download-url endpoint rejects guest download attempts with 403

Extends the e2e share helpers with apiUpdateShare, apiEnableShareWatermark
and apiPublicDownloadUrl, and documents the new cases in the e2e README.
2026-08-08 11:45:06 +08:00
Yiling-J 707c091c9b fix(webui): persist project sorting and prevent full page flash (#276) 2026-08-08 10:37:45 +08:00
Yiling-J d3f5892dd2 feat(share): add allow download config to share links (#275)
* feat(share): add allow download config to share links

* fix(share): hide download in public share list page when disabled
2026-08-08 10:25:02 +08:00
Yiling-J 70b6c33204 fix(share): resolve symlinks for download URLs and enable card download action (#274) 2026-08-07 23:24:24 +08:00
Yiling-J 624a3a6a54 feat(webui): remove original-file display fallbacks, use proxies only (#273)
* feat(webui): remove original-file display fallbacks, use proxies only

WebUI now never uses the raw original file for display. All viewers
(image, video, compare, pdf) render exclusively from transcoded proxies;
when no proxy exists the viewer shows an unavailable placeholder instead
of falling back to media.original.

- getBestTranscode: drop the isRaw fallback candidates
- video-viewer / compare-video-pane: remove the synthetic 'Original'
  resolution entry and the original.downloadUrl hasMedia gate
- image-viewer / compare-image-pane: remove original.downloadUrl default
- pdf-viewer: require pdfTranscode.url (no original fallback)
- download menus (video-control-bar, breadcrumb-nav): use
  media.original.key for the 'Original' download option instead of the
  isRaw transcode marker entry

Backend:
- transcode-video workflow no longer pushes the isRaw:true marker entry
  into videoTranscodes (it pointed at the original file key)
- remove media.original.downloadUrl from the DTO, asset service mapping,
  MediaInfo DB type, and transcode workflows/activities (it was only
  consumed by the removed display fallbacks; downloads already use key
  via the download-url endpoints)

Tests/fixtures updated; docs updated to state the proxy-only display
policy.

* refactor: remove isRaw field via data migration, clean legacy media JSON

Add a Prisma data migration that cleans legacy media JSONB on both
assets and watermark_files:
- drop the raw-original marker entries (isRaw: true) from
  videoTranscodes / imageTranscodes — they pointed at the original file
  key and were only used by the removed display fallbacks / download
  menus, which now use media.original.key directly
- strip the isRaw field from remaining transcode entries
- drop original.downloadUrl (removed from the AssetInfo DTO)

The migration is generated via prisma migrate dev --create-only and
applied automatically by migrate deploy in production. It is guarded by
a test (packages/db/src/clean-media-migration.test.ts) that seeds legacy
media JSON, runs the migration SQL, and asserts the transform on both
tables.

With the data cleaned, remove the isRaw field entirely from the codebase:
- DTO schemas + ImageTranscode/VideoTranscode interfaces
- PrismaJson MediaInfo transcode types
- watermark activity isRaw skip (and its test), watermark proxy mapping,
  agent-embedding transcode selection, webui transcode filters, and all
  test fixtures

AGENTS.md: clarify that the no-manual-migration rule applies to DDL;
data migrations (pure SQL transforms, no schema change) are allowed
inside a --create-only generated migration and must be tested.
2026-08-07 22:40:06 +08:00
Yiling-J 03aea2cb36 feat(sharelink): add sharelink watermark support (#270)
* feat(sharelink): add sharelink watermark support

* fix(sharelink): harden watermark feature against races, crashes, and tenant leaks

Addresses review findings on the sharelink watermark feature:

- fix(watermark): read back sharelink via transaction client so the
  updateShareLinkWatermark response reflects the just-committed state
  (global-client reads on a pooled connection miss uncommitted changes)
- fix(watermark): use prisma upsert on the config hash instead of
  find-then-create to avoid P2002 races on concurrent enables
- fix(watermark): resolve nested symlinks when walking the share tree and
  batch the walk level-by-level instead of one query per node
- fix(watermark): keep watermark tasks in flight from being purged by
  orphan-config GC (avoids FK violations in completing activities)
- fix(transcode): re-transcode stale 'processing' watermark rows instead
  of silently skipping (crash recovery); downscale embedded block images;
  use pino structured logging; drop unused any casts
- fix(api): scope watermark-template list/create to the caller's teams,
  reject teamless template creation, and make teamless templates
  read-only; validate watermark config required when enabling (400);
  map sharelink-not-found to 404
- fix(api): resolve symlink target ids once in public share children
  endpoint instead of twice per item
- refactor(db): dedicated WatermarkFileStatus enum (migration included)
- test: activity unit tests (init crash recovery, image + video transcode
  paths), concurrent upsert, nested-symlink resolution, API scoping and
  validation, e2e video watermark path

* refactor(transcode): move sharp usage out of watermark activity into transcodeService

The transcode package does not declare sharp as a dependency (only
@shumai/core does), so importing it directly in the watermark activity
broke CI typecheck for the transcode package.

- add transcodeService.renderSvgToPng, downscaleImageToPng and
  compositeOverlayToWebpFile encapsulating the sharp logic
- watermark activity now calls these methods instead of importing sharp
- activity tests mock the new methods (no sharp/real fixture needed)
- add unit tests for the new transcodeService helpers

* feat(watermark): restrict watermark transcode to existing image and video transcodes

* refactor(transcode): reuse transcodeVideo in watermark activity

* refactor(watermark): use Bun.hash instead of node crypto for watermark config hash

* refactor(watermark): move computeWatermarkConfigHash from dtos to core watermark-hash module

* refactor(api): delegate watermark DB queries from public-share route to watermarkService

* refactor(share): replace dynamic watermarkService import with static import

* feat(watermark): add waitForWatermarkFileActivity for in-flight watermark transcoding tasks

* refactor(asset): replace dynamic watermarkService import with static import

* test(watermark): harden purgeOrphanWatermarkConfigs coverage

Replace the single happy-path GC test with a dedicated suite covering:

- orphan config with proxies: purged, watermarkFiles removed, all four
  proxy keys deleted from S3 while the original key is preserved
- config still referenced by a share link is not purged
- config with pending/processing transcode_watermark tasks is not purged
  (in-flight guard), but completed tasks do not block purging
- pending tasks of other types (transcode_video) do not protect a config
- an S3 delete failure is non-fatal: remaining keys still deleted and the
  config is still purged
- mixed run: only the orphan config is purged while a referenced one
  survives (exact count assertion)

* feat(webui): add sharelink watermark editor and sidebar controls

* style(webui): enlarge watermark editor dialog and allocate 2/3 width to preview column

* fix(webui): override sm:max-w-lg in DialogContent to allow full 1400px width

* fix(webui): stop block click propagation and remove preview mode toggles

* fix(webui): store watermark block size as fraction of canvas width

The editor stored block.size in pixels (slider 10-120px, preview
fontSize: `${block.size}px`) while the SVG generator
(generateWatermarkSvg) interprets size as a fraction (0..1) of canvas
width. A 36px block therefore rendered as a ~36x-canvas glyph covering
the entire image.

- Keep backend fraction semantics (canvasWidth * size) so watermarks
  scale proportionally with output resolution across proxies
- Editor: defaults (text 5%, image 15%), slider ranges (1-12% / 2-50%)
  and number input now work in percent, storing a fraction
- Preview: scales blocks by the measured canvas width so WYSIWYG
- DTO schema: size constrained to (0..1) to enforce the contract
- Update DTO/editor tests to fraction sizes

* feat(webui): add single-row aspect ratio selector and 5 predefined background colors to watermark editor preview

* feat(webui): update aspect ratio to multi-toggle group and enable dot-grid pattern for all background colors

* fix(webui): update background swatches to distinct colors and share PRESET_BACKGROUND_OPTIONS array

* fix(webui): hide redundant absolute close button on watermark editor dialog header

* fix(transcode): skip raw video transcode when generating watermark proxies

The raw marker entry (isRaw: true) in videoTranscodes points at the
original source file and is only used to offer the 'Original' playback
option. It is not a transcoded proxy, so watermarking it produced a
redundant full-resolution transcode (the most expensive pass) plus an
unneeded S3 upload.

Skip entries with isRaw: true in transcodeWatermarkMediaActivity, and
cover the behavior with a unit regression test plus an e2e assertion
that exactly one watermark proxy is produced for a video asset.

* feat(webui): replace watermark image asset ID with 1MB file uploader

* fix(webui): correct watermark editor preview block sizing

The preview canvas width was measured in a useEffect([open]) that ran
before the Radix Dialog had mounted its content, so canvasRef.current was
still null, canvasWidthPx stayed 0, and every block silently fell back to
the hardcoded 640px width (block.size * (canvasWidthPx || 640)). A 100%
size therefore rendered at ~640px on an ~876px canvas (~72%), making the
preview smaller than the real watermarked output for both image and text
blocks.

- Measure the canvas via a ref callback (fires exactly when the node
  mounts, regardless of dialog mount timing) and keep a ResizeObserver
  attached for aspect-ratio/window changes.
- Use clientWidth (padding-box width) instead of getBoundingClientRect(),
  which includes the dialog's zoom-in-95 animation transform.
- Drop max-w-full/max-h-full on the preview <img> so logos scale up to
  the block size like the backend SVG rendering does, instead of being
  capped at their natural pixel size.

* fix(webui): keep watermark editor preview aspect ratio and restore config scroll

- Compute the preview canvas size with a JS contain-fit (ResizeObserver on the
  frame) instead of relying on CSS aspect-ratio + w-full/max-h-full, which
  broke the selected ratio on wide-and-short (or tall-and-narrow) windows.
- Add min-h-0 to the config ScrollArea so it shrinks to the column's remaining
  height instead of growing to its content height, restoring the scroll range.

* fix(webui): remove toast notification on template load

* fix(share): serve per-file watermark proxies in public share APIs

Stop gating watermark replacement on the share-link-wide watermarkStatus.
Public share endpoints now resolve each asset's own completed watermark
proxy and:

- replace videoTranscodes/imageTranscodes with the watermarked entries
  when the watermark file is completed;
- empty those arrays when no completed proxy exists yet (still
  transcoding or failed) so original, unwatermarked media is never
  exposed while a newly added file is being processed;
- leave non-video/image media (pdf, audio, ...) untouched, since they
  never receive watermark transcodes.

This removes the previous behavior where adding a file to a ready
watermark share flipped the whole share link to processing and served
original media for every file until the new transcode finished.

Adds API tests for detail/children endpoints (ready, in-flight, pdf, and
watermark-disabled cases) and a workflow E2E test for adding an asset to
an already-ready watermark sharelink.
2026-08-07 21:36:20 +08:00
391 changed files with 34371 additions and 803 deletions
+5 -3
View File
@@ -90,7 +90,8 @@ Add any additional context, caveats, or follow-up work.
- `bun run format`
- `bun run typecheck`
- `bun run test`
- `bun run test:e2e`
- `bun run test:e2e:app`
- `bun run test:e2e:webui`
- `bun run test:e2e:workflow`
- **Backend Testing Mandate**: Every backend feature, service method, workflow, and activity MUST be accompanied by comprehensive tests. Logic-heavy code without corresponding test coverage is considered incomplete.
@@ -285,7 +286,7 @@ describe('Team API', () => {
### Web App E2E Tests
- Located in `apps/web/e2e/**/*.spec.ts`, organized by domain under `tests/<domain>/` (e.g. `auth`, `project`).
- Run via `bun run test:e2e`.
- Run via `bun run test:e2e:app`.
- **Fixtures**: Use the `owner`, `project`, and `file` fixtures for setup — they seed data through API calls/DB (no slow UI setup). You can add more fixtures if necessary.
- **Documentation**: Every test case MUST be documented in [`apps/web/e2e/README.md`](apps/web/e2e/README.md). Add or update the corresponding entry in the README whenever you add, rename, or remove a spec.
@@ -321,7 +322,8 @@ We use `prisma-json-types-generator` to enforce strict type-safety for Prisma `J
- Development: Use `bun --bun run prisma migrate dev` to create and apply migrations during development.
- Production: Use `bun --bun run prisma migrate deploy` to apply pending migrations in production environments.
- **No Manual Migration Creation**: Never create migration SQL files or directories manually by hand. Always use Prisma CLI commands (e.g. `bun --bun run prisma migrate dev --create-only` to generate a migration template, or `bun --bun run prisma migrate dev`) so Prisma correctly tracks migration metadata and checksums.
- **No Manual DDL Creation**: Never hand-write **schema (DDL) migration** files or directories. Always generate them with Prisma CLI (`bun --bun run prisma migrate dev --create-only` to create a template, then edit it if needed, or `bun --bun run prisma migrate dev` to apply) so Prisma correctly tracks migration metadata and checksums.
- **Data Migrations Are Allowed**: Pure **data migration** SQL (no schema change) may be written by hand, but it MUST live inside a migration generated via `bun --bun run prisma migrate dev --create-only` so it is tracked and applied automatically.
- **No Automatic Dev DB Reset**: Do not run `prisma migrate reset --force` or commands that force-reset the database automatically. If migrations become out of sync or a reset is required, stop executing, report the situation to the user, and present suggested manual cleanup/reset steps for the user to execute.
### Commands
+8 -1
View File
@@ -24,12 +24,16 @@ Shumai is an open-source Frame.io alternative built for creative teams to collab
* **Granular Access Control**: Manage workspace permissions with team-level and project-level role-based access control.
* **Distributed Transcoding via Temporal**: Offload resource-intensive video transcoding to a background worker pool orchestrated by Temporal.
* **Custom Asset Metadata**: Define dynamic metadata fields tailored to your production pipeline.
* **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).
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:
* **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.
* **Model Context Protocol (MCP)**: Connect agents to external tools and APIs through remote MCP servers, with OAuth authentication and per-agent MCP access.
* **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).
@@ -43,7 +47,7 @@ https://github.com/user-attachments/assets/1186067a-72c0-41b9-836f-987438f2332a
> [!NOTE]
> **Media Processing & Storage:** When uploading media, Shumai always preserves and stores your original raw file. Note that the file size shown in the system represents the original file size and does not include the size of any transcoded files. For all media types (both images and videos), Shumai creates a 480p WebP poster image to serve as the preview in the file list view. Additionally:
> **Media Processing & Storage:** When uploading media, Shumai always preserves and stores your original raw file. Note that the file size shown in the system represents the original file size and does not include the size of any transcoded files. For all media types (both images and videos), Shumai creates a 300p WebP poster image to serve as the preview in the file list view. Additionally:
> * **For Images:** Shumai generates a high-quality WebP proxy at the exact same resolution as your original file for optimized viewing.
> * **For Videos:** It generates at least one proxy video (depending on your transcoding settings), alongside a sprite image and a small preview video (capped at 1600 frames) to enable fast timeline scrubbing and lightning-quick previews.
@@ -242,11 +246,14 @@ BETTER_AUTH_SECRET=ySxs7DxzHDZBbeeHNPEwBuspYwipBqz5Gk5XdBjNhWw=
STORAGE_BACKEND=local
SHUMAI_SERVER_PORT=3000
AWS_ENDPOINT_URL_S3=http://localhost:3000
# Optional: base URL for MCP OAuth redirects (defaults to BETTER_AUTH_URL)
MCP_OAUTH_REDIRECT_BASE_URL=http://localhost:3000
```
> [!NOTE]
> `SHUMAI_SERVER_PORT` sets the port the server starts on, while `AWS_ENDPOINT_URL_S3` is used by the browser to build file upload URLs.
> If deploying on a remote server (e.g. `http://123.456.7.8`) with a mapped port (e.g. `12345:3000` in docker-compose), set `AWS_ENDPOINT_URL_S3` to `http://123.456.7.8:12345`.
> `MCP_OAUTH_REDIRECT_BASE_URL` is only needed when MCP servers use OAuth: the authorization redirect URI defaults to `{BETTER_AUTH_URL}/api/mcp/oauth/callback`; set it to an externally reachable URL if the app is served behind a proxy.
#### Step 6: Run Shumai
+5 -1
View File
@@ -25,12 +25,16 @@ Shumai 是一个开源的 Frame.io 替代方案,专为创意团队打造,让
* **细粒度权限控制**:支持按团队、项目设置角色权限,方便管理不同成员的访问范围。
* **基于 Temporal 的分布式转码**:把吃资源的视频转码任务交给后台 worker 池处理,由 Temporal 统一调度。
* **自定义素材元数据**:可以按你的制作流程,自由定义动态元数据字段。
* **分享链接水印**:通过可自定义的文字和图片水印保护共享媒体,并将水印配置保存为模板以便重复使用。
* **丰富的文件格式支持**:支持预览常见创意文件格式,包括图片(支持 PSD)、视频、音频和文档,同时可上传和存储任意类型的文件。
* **基于 Gotenberg 的文档 PDF 转码代理**:通过集成 [Gotenberg](https://docs.shumai.one/using-shumai/gotenberg) 支持将 Word、PowerPoint、Excel、Markdown、HTML 和 CSV 文档高质量转换为 PDF 代理文件进行在线预览。
但 Shumai 不仅仅只满足于 Frame.io 的开源替代。随着 GPT-Image-2、Seedance 2.5 这类强大模型的问世,AI已经生成产品级的图片/视频。很多时候,你只要给一句提示词,就能直接生成或修改图片和视频,而不用再打开 Photoshop、Premiere 或者 Houdini。也正因为这样,Shumai 才把 AI Agent 做成了核心能力:
* **Agent 就像团队成员**:你可以在素材评论区里直接用 `@` 提到 AI Agent,像拉一个真实同事进来一起看稿一样。
* **Agent 也能当你的私聊助手**:你可以单独和它聊天,让它帮你查东西、做任务。
* **自定义技能和工具**:你可以给 Agent 接上自己的脚本、工具和自动化能力。
* **Model Context Protocol (MCP) 支持**:通过远程 MCP 服务端为 Agent 接入外部工具与 API,支持 OAuth 鉴权与按 Agent 独立分配访问权限。
* **沙箱隔离执行**:Agent 生成的脚本会在隔离环境里运行,更安全。
* **AI 自动补全元数据**:新素材上传后,系统可以自动帮你补一些元数据。
* **语义搜索**:支持按画面内容或语义找素材,底层用的是向量 embedding(Gemini Embedding 2)。
@@ -40,7 +44,7 @@ Shumai 是一个开源的 Frame.io 替代方案,专为创意团队打造,让
https://github.com/user-attachments/assets/1186067a-72c0-41b9-836f-987438f2332a
> [!NOTE]
> **媒体处理与存储机制:** 上传媒体文件后,Shumai 始终会保留并存储原始文件。请注意,系统中显示的文件大小为原始文件的大小,不包含转码后生成的代理文件大小。无论图片还是视频,都会额外生成一张 480p 的 WebP 封面图,作为文件列表中的预览图。此外:
> **媒体处理与存储机制:** 上传媒体文件后,Shumai 始终会保留并存储原始文件。请注意,系统中显示的文件大小为原始文件的大小,不包含转码后生成的代理文件大小。无论图片还是视频,都会额外生成一张 300p 的 WebP 封面图,作为文件列表中的预览图。此外:
>
> * **图片:** 会生成一份与原图分辨率完全一致的高质量 WebP 转码版本,在保证画质的同时提升浏览性能。
> * **视频:** 会根据转码配置生成至少一个代理视频,同时生成雪碧图(Sprite)和一段最长 1600 帧的低分辨率转码视频,用于实现快速拖动时间轴和即时视频预览。
+1 -1
View File
@@ -1,6 +1,6 @@
{
"name": "@shumai/agent-app",
"version": "0.3.3",
"version": "0.3.6",
"private": true,
"type": "module",
"bin": {
+1 -1
View File
@@ -1,6 +1,6 @@
{
"name": "@shumai/cli",
"version": "0.3.3",
"version": "0.3.6",
"private": true,
"type": "module",
"bin": {
+1 -1
View File
@@ -1,6 +1,6 @@
{
"name": "@shumai/transcode-app",
"version": "0.3.3",
"version": "0.3.6",
"private": true,
"type": "module",
"bin": {
+4 -2
View File
@@ -2,7 +2,7 @@
Fullstack end-to-end tests for the Shumai web app. They run against a real backend
(pgvector container + local S3 storage) served on `http://localhost:5200` and are
executed with Playwright via `bun run test:e2e`.
executed with Playwright via `bun run test:e2e:app`.
## Structure
@@ -68,7 +68,7 @@ apps/web/e2e/
| Test | File |
|---|---|
| Owner creates a project with a cover image | `tests/project/create-project.spec.ts` |
| Owner uploads a file via the "Upload File" context menu action | `tests/project/upload-file.spec.ts` |
| Owner uploads a file or an unsupported file via the "Upload File" context menu action | `tests/project/upload-file.spec.ts` |
| Owner deletes a file, finds it in recently deleted, and restores it | `tests/project/delete-restore.spec.ts` |
| Owner creates a share link from a file context menu and lands on the share page | `tests/project/create-share-link.spec.ts` |
| Owner protects a share with a password; guests must enter it to view | `tests/project/share-password.spec.ts` |
@@ -84,6 +84,8 @@ apps/web/e2e/
| Owner searches the file list by Chinese, Japanese, and Korean name keywords | `tests/project/search-file-list.spec.ts` |
| Owner searches the file list with a keyword and a filter condition | `tests/project/search-file-list.spec.ts` |
| 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` |
### file
| Test | File |
+64 -3
View File
@@ -3,6 +3,7 @@ import type { APIRequestContext, Locator, Page } from '@playwright/test'
interface CreateShareResponse {
id?: string
name?: string
rootFolderId?: string
}
/**
@@ -23,7 +24,7 @@ export async function apiCreateShare(
request: APIRequestContext,
projectId: string,
name: string,
): Promise<{ id: string; name: string }> {
): Promise<{ id: string; name: string; rootFolderId: string }> {
const res = await request.post(`/api/projects/${projectId}/shares`, {
data: { name },
})
@@ -31,10 +32,10 @@ export async function apiCreateShare(
throw new Error(`Create share API failed (${res.status()}): ${await res.text()}`)
}
const body = (await res.json()) as CreateShareResponse
if (!body.id || !body.name) {
if (!body.id || !body.name || !body.rootFolderId) {
throw new Error(`Create share returned an unexpected response: ${JSON.stringify(body)}`)
}
return { id: body.id, name: body.name }
return { id: body.id, name: body.name, rootFolderId: body.rootFolderId }
}
/** Adds assets to a share link through the API. */
@@ -51,6 +52,66 @@ export async function apiAddAssetsToShare(
}
}
/** Updates share link settings (e.g. `allowDownload`) through the API. */
export async function apiUpdateShare(
request: APIRequestContext,
shareId: string,
patch: { allowDownload?: boolean },
): Promise<void> {
const res = await request.put(`/api/shares/${shareId}`, { data: patch })
if (!res.ok()) {
throw new Error(`Update share API failed (${res.status()}): ${await res.text()}`)
}
}
/**
* Enables a text watermark on the share link through the API. Uses the same
* default block shape the watermark editor produces (a "CONFIDENTIAL" text
* block), so the transcode workflow runs against a realistic config.
*/
export async function apiEnableShareWatermark(
request: APIRequestContext,
shareId: string,
): Promise<void> {
const res = await request.put(`/api/shares/${shareId}/watermark`, {
data: {
enabled: true,
config: {
blocks: [
{
id: `wm-${Date.now()}`,
type: 'text',
text: 'CONFIDENTIAL',
x: 0.5,
y: 0.5,
// size is a fraction (0..1) of the canvas width
size: 0.05,
color: '#999999',
opacity: 0.5,
rotation: -30,
},
],
},
},
})
if (!res.ok()) {
throw new Error(`Enable share watermark API failed (${res.status()}): ${await res.text()}`)
}
}
/** Requests a public download URL. Returns status + body for assertions. */
export async function apiPublicDownloadUrl(
request: APIRequestContext,
shareId: string,
fileId: string,
key: string,
): Promise<{ status: number; body: unknown }> {
const res = await request.post(`/api/shares/${shareId}/files/${fileId}/download-url`, {
data: { key },
})
return { status: res.status(), body: await res.json().catch(() => null) }
}
/** Uploads a file asset through the official API upload task endpoints. */
export async function apiUploadFile(
request: APIRequestContext,
@@ -0,0 +1,184 @@
import { expect, test } from '../../fixtures'
import {
apiAddAssetsToShare,
apiCreateShare,
apiEnableShareWatermark,
apiPublicDownloadUrl,
apiUpdateShare,
fileCard,
} from '../../helpers/files'
/**
* The watermarked + download-disabled combination is frequently used together:
* guests can preview the content but never download it, and any previewed proxy
* carries a watermark. This covers both watermarkable media types (image and
* video) and asserts, per type:
* - the public share list page exposes no download affordance,
* - the public share file detail page exposes no download affordance,
* - the proxy loaded in the detail page is the watermarked version, and
* - the download-url endpoint rejects guest download attempts with 403.
*/
for (const mediaType of ['image', 'video'] as const) {
// NOTE: `test.use` must be scoped per describe block — a bare `test.use`
// inside a `for` loop leaks the last iteration's value to every test.
test.describe(`${mediaType} share`, () => {
test.use({ fileOptions: { mediaType } })
// Transcoding (original + watermark) happens through the local workflow
// executor, so this test needs a much larger budget than the 60s default.
test.setTimeout(300_000)
test('with watermark + download disabled: no download buttons, watermarked proxy', async ({
file,
browser,
prisma,
}) => {
const { context, projectId, fileName, fileId } = file
// The watermark transcode re-encodes from the existing transcode slots, so
// the original transcode must finish first.
await expect
.poll(
async () => {
const asset = await prisma.asset.findUnique({ where: { id: fileId } })
return asset?.status
},
{ timeout: 60_000 },
)
.toBe('processed')
// Seed the share through the API (setup, not the flow under test)
const share = await apiCreateShare(context.request, projectId, 'Watermarked Share')
await apiAddAssetsToShare(context.request, share.id, [fileId])
await apiUpdateShare(context.request, share.id, { allowDownload: false })
await apiEnableShareWatermark(context.request, share.id)
// Wait for the watermark transcode to complete and the share to be ready
await expect
.poll(
async () => {
const link = await prisma.shareLink.findUnique({ where: { id: share.id } })
return link?.watermarkStatus
},
{ timeout: 120_000 },
)
.toBe('ready')
const saved = await prisma.shareLink.findUnique({ where: { id: share.id } })
expect(saved?.allowDownload).toBe(false)
expect(saved?.watermarkConfigId).not.toBeNull()
// The share root contains a symlink pointing at the real asset; the public
// detail page navigates with the symlink id (mirrors the real double-click flow).
const symlink = await prisma.asset.findFirst({
where: { parentId: share.rootFolderId, targetId: fileId },
})
expect(symlink).not.toBeNull()
// Original (unwatermarked) transcode keys, to prove they are never served
const asset = await prisma.asset.findUnique({ where: { id: fileId } })
const media = asset?.media as {
imageTranscodes?: Array<{ key: string }>
videoTranscodes?: Array<{ key: string }>
original?: { key: string } | null
} | null
const originalKeys =
(mediaType === 'image' ? media?.imageTranscodes : media?.videoTranscodes)?.map(
(t) => t.key,
) ?? []
const guestContext = await browser.newContext()
const guestPage = await guestContext.newPage()
try {
// ---------------- Public share list page ----------------
await guestPage.goto(`/share/${share.id}`)
await expect(fileCard(guestPage, fileName)).toBeVisible()
// Card context menu: no Download item
const card = fileCard(guestPage, fileName)
const kebab = card.locator('button', {
has: guestPage.locator('svg.lucide-ellipsis'),
})
await kebab.click()
await expect(guestPage.locator('[data-radix-menu-content]').first()).toBeAttached()
await expect(guestPage.getByRole('menuitem', { name: 'Download' })).toHaveCount(0)
await guestPage.keyboard.press('Escape')
// Wait for the Radix menu to fully unmount before interacting again:
// while its exit animation is running its dismiss layer can intercept
// the outside pointerdown and swallow the next click.
await guestPage
.waitForFunction(() => !document.querySelector('[data-radix-menu-content]'), null, {
timeout: 10_000,
})
.catch(() => {})
// Selection bar: selecting the file must not surface a Download button.
// Click the card checkbox (selects directly) instead of the card body:
// the preview area (video sprite scrubber) re-renders on hover and can
// race with a body click.
const checkbox = card.getByRole('checkbox')
await checkbox.click()
await expect(guestPage.getByText(/1 file selected/)).toBeVisible()
await expect(guestPage.getByRole('button', { name: 'Download' })).toHaveCount(0)
// ---------------- Public share file detail page ----------------
// Capture every network request so we can prove the loaded proxy is the
// watermarked one and no original transcode key is ever requested.
const watermarkedRequests: string[] = []
const allRequests: string[] = []
guestPage.on('request', (req) => {
const url = req.url()
allRequests.push(url)
if (url.includes('-watermark-')) watermarkedRequests.push(url)
})
const detailFileId = symlink!.id
await guestPage.goto(`/share/${share.id}/files/${detailFileId}`)
// The viewer (image canvas / video element) renders the proxy
if (mediaType === 'image') {
await expect(guestPage.locator('canvas').first()).toBeVisible({ timeout: 30_000 })
} else {
await expect(guestPage.locator('video').first()).toBeVisible({ timeout: 30_000 })
}
// The proxy actually loaded is the watermarked version, and no original
// (unwatermarked) transcode key was requested
await expect.poll(() => watermarkedRequests.length, { timeout: 30_000 }).toBeGreaterThan(0)
const leaked = allRequests.filter((url) => originalKeys.some((key) => url.includes(key)))
expect(leaked).toEqual([])
// No download affordance in the viewer control bar
await expect(guestPage.getByTitle('Download')).toHaveCount(0)
await expect(guestPage.getByTitle('Download original image')).toHaveCount(0)
await expect(guestPage.getByRole('button', { name: 'Download' })).toHaveCount(0)
// Top-nav file dropdown: no Download item (video: also no resolution submenu)
await guestPage.getByRole('button', { name: new RegExp(fileName) }).click()
await expect(guestPage.locator('[data-radix-menu-content]').first()).toBeAttached()
await expect(guestPage.getByRole('menuitem', { name: 'Download' })).toHaveCount(0)
if (mediaType === 'video') {
await expect(
guestPage.locator('[data-radix-menu-content]').getByText('Original', { exact: true }),
).toHaveCount(0)
await expect(
guestPage.locator('[data-radix-menu-content]').getByText('MP4', { exact: true }),
).toHaveCount(0)
}
// ---------------- Backend enforcement ----------------
// Guests cannot obtain a download URL even when they know the storage key
const originalKey = originalKeys[0] || media?.original?.key || ''
const download = await apiPublicDownloadUrl(
guestContext.request,
share.id,
detailFileId,
originalKey,
)
expect(download.status).toBe(403)
} finally {
await guestContext.close()
}
})
})
}
@@ -47,3 +47,39 @@ test('owner uploads a file via the "Upload File" context menu action', async ({
const projectRow = await prisma.project.findUnique({ where: { id: projectId } })
expect(asset!.parentId).toBe(projectRow?.rootFolderId)
})
test('owner uploads an unsupported file via context menu action', async ({ project, prisma }) => {
const { page, projectId } = project
const fileName = `e2e-upload-${Date.now()}.bin`
const binBuffer = Buffer.from([0x00, 0x01, 0x02, 0x03])
await page.goto(`/projects/${projectId}`)
await expect(page.getByText('This folder is empty')).toBeVisible()
await page.getByText('This folder is empty').click({ button: 'right' })
const [fileChooser] = await Promise.all([
page.waitForEvent('filechooser'),
page.getByRole('menuitem', { name: 'Upload File' }).click(),
])
await fileChooser.setFiles({
name: fileName,
mimeType: 'application/octet-stream',
buffer: binBuffer,
})
const card = fileCard(page, fileName)
await expect(card).toBeVisible()
await expect
.poll(
async () => {
const asset = await prisma.asset.findFirst({ where: { name: fileName } })
return asset?.status
},
{ timeout: 30_000 },
)
.toBe('processed')
// Verify that the file card shows the generic file icon and is not stuck in uploading state
await expect(card.locator('svg.lucide-file')).toBeVisible({ timeout: 10_000 })
})
+1 -1
View File
@@ -1,6 +1,6 @@
{
"name": "@shumai/web-app",
"version": "0.3.3",
"version": "0.3.6",
"private": true,
"type": "module",
"dependencies": {
+29 -14
View File
@@ -33,7 +33,7 @@
},
"apps/agent": {
"name": "@shumai/agent-app",
"version": "0.3.2",
"version": "0.3.5",
"bin": {
"shumai-agent": "./src/index.ts",
},
@@ -45,7 +45,7 @@
},
"apps/cli": {
"name": "@shumai/cli",
"version": "0.3.2",
"version": "0.3.5",
"bin": {
"shumai-cli": "./src/index.ts",
},
@@ -60,7 +60,7 @@
},
"apps/transcode": {
"name": "@shumai/transcode-app",
"version": "0.3.2",
"version": "0.3.5",
"bin": {
"shumai-transcode": "./src/index.ts",
},
@@ -72,7 +72,7 @@
},
"apps/web": {
"name": "@shumai/web-app",
"version": "0.3.2",
"version": "0.3.5",
"dependencies": {
"@shumai/agent": "workspace:*",
"@shumai/api": "workspace:*",
@@ -92,7 +92,7 @@
},
"packages/agent": {
"name": "@shumai/agent",
"version": "0.3.2",
"version": "0.3.5",
"dependencies": {
"@anthropic-ai/sandbox-runtime": "0.0.66",
"@earendil-works/pi-agent-core": "0.82.1",
@@ -117,7 +117,7 @@
},
"packages/api": {
"name": "@shumai/api",
"version": "0.3.2",
"version": "0.3.5",
"dependencies": {
"@hono/zod-validator": "0.7.6",
"@shumai/core": "workspace:*",
@@ -131,10 +131,11 @@
},
"packages/core": {
"name": "@shumai/core",
"version": "0.3.2",
"version": "0.3.5",
"dependencies": {
"@earendil-works/pi-agent-core": "0.82.1",
"@earendil-works/pi-ai": "0.82.1",
"@modelcontextprotocol/client": "2.0.0",
"@shumai/db": "workspace:*",
"@shumai/dtos": "workspace:*",
"@sinclair/typebox": "0.34.49",
@@ -151,11 +152,13 @@
"pino": "10.3.1",
"sharp": "0.34.5",
"tweetnacl": "1.0.3",
"typebox": "1.1.38",
"ulid": "3.0.2",
"yaml": "2.9.0",
"zod": "4.4.3",
},
"devDependencies": {
"@modelcontextprotocol/server": "2.0.0",
"@types/adm-zip": "0.5.8",
"@types/extract-zip": "2.0.3",
"@types/pdfkit": "0.17.6",
@@ -163,7 +166,7 @@
},
"packages/db": {
"name": "@shumai/db",
"version": "0.3.2",
"version": "0.3.5",
"dependencies": {
"@earendil-works/pi-agent-core": "0.82.1",
"@prisma/adapter-pg": "7.8.0",
@@ -179,7 +182,7 @@
},
"packages/dtos": {
"name": "@shumai/dtos",
"version": "0.3.2",
"version": "0.3.5",
"dependencies": {
"@earendil-works/pi-agent-core": "0.82.1",
"zod": "4.4.3",
@@ -187,7 +190,7 @@
},
"packages/e2e": {
"name": "@shumai/e2e",
"version": "0.3.2",
"version": "0.3.5",
"dependencies": {
"@earendil-works/pi-agent-core": "0.82.1",
"@google/genai": "1.52.0",
@@ -202,11 +205,11 @@
},
"packages/tableprinter": {
"name": "@shumai/tableprinter",
"version": "0.3.2",
"version": "0.3.5",
},
"packages/transcode": {
"name": "@shumai/transcode",
"version": "0.3.2",
"version": "0.3.5",
"dependencies": {
"@shumai/core": "workspace:*",
"@shumai/db": "workspace:*",
@@ -220,7 +223,7 @@
},
"packages/webui": {
"name": "@shumai/webui",
"version": "0.3.2",
"version": "0.3.5",
"dependencies": {
"@base-ui/react": "1.5.0",
"@dnd-kit/abstract": "0.4.0",
@@ -318,7 +321,7 @@
},
"packages/workflow-core": {
"name": "@shumai/workflow-core",
"version": "0.3.2",
"version": "0.3.5",
"dependencies": {
"@shumai/core": "workspace:*",
"@shumai/db": "workspace:*",
@@ -735,6 +738,12 @@
"@mistralai/mistralai": ["@mistralai/mistralai@2.2.6", "", { "dependencies": { "@opentelemetry/semantic-conventions": "^1.40.0", "ws": "^8.18.0", "zod": "^3.25.0 || ^4.0.0", "zod-to-json-schema": "^3.25.0" }, "peerDependencies": { "@opentelemetry/api": "^1.9.0" }, "optionalPeers": ["@opentelemetry/api"] }, "sha512-W8pX7zHxjJvMIpw8JMxeJEleapXX0Q9NPszdNzqkM3MIEoIGPObdodujj+WHteXEvGfaP/AMwlNyRfEzSY6dQQ=="],
"@modelcontextprotocol/client": ["@modelcontextprotocol/client@2.0.0", "", { "dependencies": { "@modelcontextprotocol/core": "2.0.0", "cross-spawn": "^7.0.5", "eventsource": "^3.0.2", "eventsource-parser": "^3.0.0", "jose": "^6.1.3", "pkce-challenge": "^5.0.0", "zod": "^4.2.0" } }, "sha512-8f1OghQ2rjzIOfqgUCP+8GiUWqRs89njoWLNqAe8kWmDePv3s1fZXseej+QXemssEuuOvLLmLO/kqM3IQHtISw=="],
"@modelcontextprotocol/core": ["@modelcontextprotocol/core@2.0.0", "", { "dependencies": { "zod": "^4.2.0" } }, "sha512-pJCEwGG7Lfr/+PQp9ZTwKXNeO5wzbfKL7H3MYpCorM4oFBoQrdjnBgEoqG+RjhsvS1FKrDbKux+M1HhlnGWqcA=="],
"@modelcontextprotocol/server": ["@modelcontextprotocol/server@2.0.0", "", { "dependencies": { "@modelcontextprotocol/core": "2.0.0", "zod": "^4.2.0" } }, "sha512-YhHWdHfpFMQfd0prsEnxKeS3Qz3ytIGmsS0sth4KDjnacIT7hxk6hXHkJ9KysxlkvTM+WZAtQbbcUhdoP4Hvtw=="],
"@napi-rs/canvas": ["@napi-rs/canvas@1.0.2", "", { "optionalDependencies": { "@napi-rs/canvas-android-arm64": "1.0.2", "@napi-rs/canvas-darwin-arm64": "1.0.2", "@napi-rs/canvas-darwin-x64": "1.0.2", "@napi-rs/canvas-linux-arm-gnueabihf": "1.0.2", "@napi-rs/canvas-linux-arm64-gnu": "1.0.2", "@napi-rs/canvas-linux-arm64-musl": "1.0.2", "@napi-rs/canvas-linux-riscv64-gnu": "1.0.2", "@napi-rs/canvas-linux-x64-gnu": "1.0.2", "@napi-rs/canvas-linux-x64-musl": "1.0.2", "@napi-rs/canvas-win32-arm64-msvc": "1.0.2", "@napi-rs/canvas-win32-x64-msvc": "1.0.2" } }, "sha512-EYEqlMYaCbpZDz+IgDH5xp9MTd3ui4dmGqbQYryhMLnSRxrhHKq5KQWHHKxFUcEP4Hp8/BWgvqXocX4j7iSbOQ=="],
"@napi-rs/canvas-android-arm64": ["@napi-rs/canvas-android-arm64@1.0.2", "", { "os": "android", "cpu": "arm64" }, "sha512-IMXKVQod0ol4vt3gmClUfXz4JAgHYESGPCUqmH3lQxBoL0K/2greJaQE1HVBVxWWFKfLc4OLZVdxg7kXVyXv+g=="],
@@ -1761,6 +1770,10 @@
"events-universal": ["events-universal@1.0.1", "", { "dependencies": { "bare-events": "^2.7.0" } }, "sha512-LUd5euvbMLpwOF8m6ivPCbhQeSiYVNb8Vs0fQ8QjXo0JTkEHpz8pxdQf0gStltaPpw0Cca8b39KxvK9cfKRiAw=="],
"eventsource": ["eventsource@3.0.7", "", { "dependencies": { "eventsource-parser": "^3.0.1" } }, "sha512-CRT1WTyuQoD771GW56XEZFQ/ZoSfWid1alKGDYMmkt2yl8UXrVR4pspqWNEcqKvVIzg6PAltWjxcSSPrboA4iA=="],
"eventsource-parser": ["eventsource-parser@3.1.0", "", {}, "sha512-kJezFj9YFAMLeORyi7aCLxLbD5/qWMQnoMVlVPyHIll7lgRJCc3JVln9Vgl9nwQi0YkMnhdGTMNn7CkRRAptMg=="],
"expect-type": ["expect-type@1.3.0", "", {}, "sha512-knvyeauYhqjOYvQ66MznSMs83wmHrCycNEN6Ao+2AeYEfxUIkuiVxdEa1qlGEPK+We3n0THiDciYSsCcgW/DoA=="],
"exsolve": ["exsolve@1.0.8", "", {}, "sha512-LmDxfWXwcTArk8fUEnOfSZpHOJ6zOMUJKOtFLFqJLoKJetuQG874Uc7/Kki7zFLzYybmZhp1M7+98pfMqeX8yA=="],
@@ -2329,6 +2342,8 @@
"pino-std-serializers": ["pino-std-serializers@7.1.0", "", {}, "sha512-BndPH67/JxGExRgiX1dX0w1FvZck5Wa4aal9198SrRhZjH3GxKQUKIBnYJTdj2HDN3UQAS06HlfcSbQj2OHmaw=="],
"pkce-challenge": ["pkce-challenge@5.0.1", "", {}, "sha512-wQ0b/W4Fr01qtpHlqSqspcj3EhBvimsdh0KlHhH8HRZnMsEa0ea2fTULOXOS9ccQr3om+GcGRk4e+isrZWV8qQ=="],
"pkcs7": ["pkcs7@1.0.4", "", { "dependencies": { "@babel/runtime": "^7.5.5" }, "bin": { "pkcs7": "bin/cli.js" } }, "sha512-afRERtHn54AlwaF2/+LFszyAANTCggGilmcmILUzEjvs3XgFZT+xE6+QWQcAGmu4xajy+Xtj7acLOPdx5/eXWQ=="],
"pkg-types": ["pkg-types@2.3.1", "", { "dependencies": { "confbox": "^0.2.4", "exsolve": "^1.0.8", "pathe": "^2.0.3" } }, "sha512-y+ichcgc2LrADuhLNAx8DFjVfgz91pRxfZdI3UDhxHvcVEZsenLO+7XaU5vOp0u/7V/wZ+plyuQxtrDlZJ+yeg=="],
+3 -1
View File
@@ -34,7 +34,8 @@
"using-shumai/notifications",
"using-shumai/metadata",
"using-shumai/collections",
"using-shumai/share-links"
"using-shumai/share-links",
"using-shumai/gotenberg"
]
},
{
@@ -44,6 +45,7 @@
"using-shumai/agents",
"using-shumai/agent-skills",
"using-shumai/agent-tools",
"using-shumai/mcp-servers",
"using-shumai/agent-sandbox"
]
},
Binary file not shown.

Before

Width:  |  Height:  |  Size: 45 KiB

After

Width:  |  Height:  |  Size: 82 KiB

+82
View File
@@ -0,0 +1,82 @@
---
title: Document PDF Conversion with Gotenberg
description: Convert Office documents, HTML, Markdown, CSV, and TXT files into high-fidelity PDF proxies for in-browser previewing.
---
Office documents, HTML pages, Markdown files, spreadsheets, and plain-text files cannot be rendered natively in web browsers. Shumai uses [Gotenberg](https://gotenberg.dev), an open-source, Docker powered conversion API — to turn these files into PDF proxy assets for seamless in-browser previewing.
Gotenberg performs the conversion using:
- **LibreOffice** for Office documents, spreadsheets, and plain text.
- **Headless Chromium** for HTML and Markdown files.
---
## Supported File Types
When Gotenberg is configured, Shumai automatically generates a PDF proxy for the following uploads:
| Category | Extensions | Converter |
| ------------------ | ---------------------- | ----------- |
| Word | `.doc`, `.docx` | LibreOffice |
| Excel | `.xls`, `.xlsx` | LibreOffice |
| PowerPoint | `.ppt`, `.pptx` | LibreOffice |
| OpenDocument | `.odt`, `.ods`, `.odp` | LibreOffice |
| Rich Text | `.rtf` | LibreOffice |
| HTML | `.html`, `.htm` | Chromium |
| Markdown | `.md`, `.markdown` | Chromium |
| Spreadsheets / CSV | `.csv` | LibreOffice |
| Plain text | `.txt` | LibreOffice |
---
## Configuration
Gotenberg support is opt-in and controlled by the following environment variables on the machine running the transcode workers:
| Variable | Required | Description |
| ------------------------------- | --------------- | ---------------------------------------------------------------- |
| `GOTENBERG_URL` | Yes (to enable) | Base URL of the Gotenberg service, e.g. `http://gotenberg:3000`. |
| `GOTENBERG_BASIC_AUTH_USERNAME` | No | Username when Basic Authentication is enabled on Gotenberg. |
| `GOTENBERG_BASIC_AUTH_PASSWORD` | No | Password when Basic Authentication is enabled on Gotenberg. |
### Docker Quickstart
You can start a Gotenberg container with a single command:
```bash
docker run -d --name gotenberg -p 3000:3000 gotenberg/gotenberg:8
```
If you wish to enable Basic Authentication:
```bash
docker run -d --name gotenberg -p 3000:3000 gotenberg/gotenberg:8 gotenberg --gotenberg-basic-auth-username=admin --gotenberg-basic-auth-password=secret
```
### Docker Compose Setup
Add a Gotenberg service to your `docker-compose.yaml`:
```yaml
gotenberg:
image: gotenberg/gotenberg:8
restart: unless-stopped
ports:
- '3000:3000'
```
Then point Shumai at it:
```bash
GOTENBERG_URL=http://localhost:3000
```
---
## Behavior Without Gotenberg
If Gotenberg is not configured or unreachable, Shumai degrades gracefully:
- **Office documents and HTML**: the upload completes as `processed` without a PDF proxy.
- **CSV, Markdown, and TXT**: a lightweight built-in PDF generator produces the proxy instead, with reduced fidelity.
+115
View File
@@ -0,0 +1,115 @@
---
title: MCP Servers
description: Connect your agents to external tools and APIs using Model Context Protocol.
---
Model Context Protocol (MCP) is an open standard that enables AI models to safely interface with external tools, microservices, and APIs. In Shumai, you can register remote MCP servers using standard HTTP transports (`Streamable HTTP` or `SSE`) and assign them to your AI agents.
---
## How MCP Works in Shumai
Rather than overloading model context windows with dozens of complex parameter schemas, Shumai connects to MCP servers efficiently:
- **Automatic Discovery & Metadata Caching**: When you add an MCP server, Shumai records it in your team's settings and connects to the endpoint to discover available tools, server-reported usage instructions, and description metadata. Discovery runs when you refresh the server, complete an OAuth flow, or the first time an agent calls one of its tools. These schemas are cached in your database for fast retrieval.
- **Context-Efficient Proxy Tool (`mcp`)**: Assigned MCP servers are multiplexed through a single unified `mcp` proxy tool injected into your Chat Agents. The agent can dynamically inspect server status, search tools, view parameter schemas, and invoke functions as needed without wasting LLM tokens.
- **Direct Tools Option**: For high-frequency actions, you can optionally configure specific tools as **Direct Tools** to expose them directly to the agent as top-level LLM functions alongside the `mcp` proxy.
---
## Adding an MCP Server
To register a new MCP server in Shumai:
1. Navigate to **Team Settings** and click the **MCP** tab.
2. Click **Add MCP Server**.
3. In the dialog box, enter your **Server Endpoint URL** (e.g. `https://mcp.example.com/sse` or `http://localhost:8080/mcp`).
4. Click **Create**.
> **Note:** Only the **Server Endpoint URL** is required. Shumai derives a placeholder server name from the URL immediately; the server's actual name, status, instructions, and tool inventory are discovered the first time the server is connected (via the Refresh button in the edit dialog or the first tool call by an agent).
### Optional Server Configuration
After creating a server (the create dialog only requires a URL), open its edit dialog to configure advanced settings:
- **Transport**: Choose between `Streamable HTTP` (default) or `Server-Sent Events (SSE)`.
- **Auth Strategy**: Select `Auto-detect` (default), `None`, `Bearer Token`, or `OAuth 2.0`.
- **Minimum Permission Role**: Set the minimum team role required to invoke tools on this server (`Reviewer`, `Editor`, or `Owner`).
- **Direct Tools**: Specify a list of tool names that should be exposed directly to agents as native LLM tools.
---
## Understanding Tool Configuration
In the server's edit dialog, the **Tools** section lists every discovered tool with a three-state toggle (plus **All Off** / **All Proxy** / **All Direct** bulk actions):
- **Off**: The tool is excluded and completely invisible to agents — it cannot be listed, searched, or called through the proxy, nor registered as a direct tool. Use this to hide noisy or dangerous tools.
- **Proxy** (default): The tool is available through the single `mcp` proxy tool.
- **Direct**: The tool is exposed to agents as a native top-level function with a `{server}_{tool}` prefixed name.
### The `mcp` Proxy Tool
The `mcp` proxy tool is a single function injected into an agent's context that multiplexes every MCP server assigned to that agent. Instead of loading each tool's full parameter schema up front, the agent interacts with servers on demand:
- `mcp({})` — connection and auth status of all assigned servers
- `mcp({ server: "name" })` — list a server's tools
- `mcp({ search: "query" })` — search for tools across servers (schemas included by default)
- `mcp({ describe: "tool" })` — view one tool's full parameter schema
- `mcp({ instructions: "name" })` — view a server's usage instructions
- `mcp({ server: "name", tool: "tool_name", args: {...} })` — call a tool (pass either the `{server}_{tool}` prefixed name or the original name)
- `mcp({ action: "auth-start", server: "name" })` — start OAuth for a server
Because only one compact tool (plus a short server/tool listing) occupies the context window, the proxy keeps token usage low even when a server exposes dozens of tools. The trade-off is an extra discovery round trip: the agent typically lists or searches tools first, then calls them.
### Direct Tools
Direct tools flip the trade-off in the other direction. A tool configured as **Direct** is registered as a native top-level function (e.g. `tavily_mcp_tavily_search`) that the agent can invoke immediately, exactly like any built-in tool.
Why use direct tools:
- **Faster, more reliable calls** for high-frequency actions: the full parameter schema is always in the context window, so the agent can call the tool in a single step without first discovering it through the proxy.
- **Better tool discovery**: the model sees the tool and its description up front and is more likely to reach for it at the right moment.
The cost: every direct tool permanently consumes context tokens for its schema, so reserve **Direct** for frequently used or critical tools and keep large MCP servers on **Proxy** to avoid unnecessary context overhead. Direct tools are still subject to the same role-based permission checks as proxy calls, and the `mcp` proxy tool remains available for discovery, auth, and status.
---
## Authentication Modes
Shumai supports several authentication strategies for securing access to MCP endpoints:
### 1. No Auth (`none`)
Used for public or local MCP servers that do not require credentials.
### 2. Bearer Token (`bearer`)
Provide a static API token or key. Shumai attaches this token in the `Authorization: Bearer <token>` header for all transport requests.
### 3. OAuth 2.0 (`oauth`)
For MCP endpoints protected by OAuth identity providers:
- **Authorization Code + PKCE**: Click **Connect** on the server card in Team Settings. Shumai opens a secure OAuth popup window directing you to the identity provider. After approving permissions, the browser automatically redirects back to Shumai, completes token exchange, and refreshes server tools.
- **Client Credentials**: Provide a `Client ID` and `Client Secret` for automated server-to-server token acquisition.
---
## Assigning MCP Servers to Agents
By default, newly added MCP servers are **not assigned to any agent**. To give an agent access to an MCP server:
1. Navigate to **Team Settings** > **Agents**.
2. Click on the target agent to open its configuration dialog.
3. Scroll down to the **MCP Servers** section.
4. Toggle the switch next to the MCP server(s) you want to authorize for this agent.
5. Click **Save Changes**.
---
## Role-Based Access Control
Each MCP server has a **Minimum Required Role** setting (`Reviewer`, `Editor`, or `Owner`):
- When an agent attempts to call a tool on an MCP server, Shumai verifies the role of the user interacting with the agent.
- If the user's role does not meet the minimum requirement, tool execution is blocked with a permission error message, preventing unauthorized actions.
+26
View File
@@ -14,6 +14,8 @@ Shumai allows you to collaborate with external stakeholders who do not have acco
3. Configure the share link in the right sidebar. You can:
- Add password protection
- Set an expiration date
- Allow or disallow downloads
- Add a watermark to previews
- Configure which metadata fields are visible to recipients
4. Click **Copy Link** at the bottom of the sidebar, then send the link to your client or stakeholder.
@@ -41,6 +43,30 @@ Set an optional date and time after which the link becomes inactive. Once the da
Secure sensitive work by adding a password. External users visiting the link will be prompted to enter the correct password before they can view the assets.
### Allow Download
Control whether visitors can download the shared files. When **Allow download** is turned off:
- All download buttons are hidden on the public share page (file cards, selection bar, viewer control bars, and the top navigation).
Guests can still preview the files; only downloading is blocked. This is often combined with a watermark so previews remain viewable but protected.
### Watermark
Overlay a watermark (e.g. a "CONFIDENTIAL" text label or a logo image) on every preview shown through the share link. Open the watermark editor, arrange the blocks, and save.
Watermarking is **lazy and per-share-link** to keep storage costs low:
- The watermark transcode is only triggered when you **enable the watermark on a share link** — Shumai does **not** pre-generate watermark copies for every file in your workspace.
- All video and image assets already in the share are transcoded at that moment (the sidebar shows a _processing_ status until it finishes).
- Files and folders **added to the share link later are automatically transcoded too**, so the watermark always covers the full share without any manual steps.
- Since watermark copies are only produced for assets that are actually shared through a watermarked link, files that are never shared (or shared through non-watermarked links) never consume extra storage for watermark proxies. This can save a very large amount of storage on big libraries.
Notes:
- Only **video and image** proxies are watermarked; other media types (PDF, audio, ...) are not affected.
- While the watermark is still processing, previews are hidden rather than exposing the original, unwatermarked proxy.
### Default Sort Order
Set a default sorting rule for the shared page (e.g. sorting by name or version) to ensure the client views the files in the intended order.
+3 -4
View File
@@ -1,6 +1,6 @@
{
"name": "shumai",
"version": "0.3.3",
"version": "0.3.6",
"private": true,
"type": "module",
"repository": {
@@ -18,11 +18,10 @@
"typecheck": "tsc --noEmit",
"lint": "eslint . --ext ts,tsx --report-unused-disable-directives --max-warnings 0",
"test": "bun --bun vitest run",
"test:e2e": "playwright test --project=harness-chromium --project=app-chromium",
"test:e2e:app": "playwright test --project=app-chromium",
"test:e2e:webui": "E2E_SKIP_APP_SERVER=true playwright test --project=harness-chromium",
"test:e2e:all": "playwright test",
"test:e2e:workflow": "bun --bun vitest run -c packages/e2e/vitest.config.ts",
"test:e2e:ui": "playwright test --ui --project=harness-chromium --project=app-chromium",
"test:e2e:report": "playwright show-report",
"test:e2e:install": "playwright install --with-deps",
"harness:dev": "bun run packages/webui/e2e/harness/serve.ts",
"format": "prettier --write .",
+1 -1
View File
@@ -1,6 +1,6 @@
{
"name": "@shumai/agent",
"version": "0.3.3",
"version": "0.3.6",
"private": true,
"type": "module",
"main": "./src/index.ts",
+147
View File
@@ -1089,6 +1089,24 @@ describe('Agent Database Activities Integration', () => {
},
})
// Create two team skills, only one of which is enabled for the agent
const enabledSkill = await prisma.skill.create({
data: {
name: 'Enabled Chat Skill',
assetId: 'asset-enabled',
hash: 'enabled-hash',
teamId: team.id,
},
})
const disabledSkill = await prisma.skill.create({
data: {
name: 'Disabled Chat Skill',
assetId: 'asset-disabled',
hash: 'disabled-hash',
teamId: team.id,
},
})
const agent = await prisma.agent.create({
data: {
id: agentUser.id,
@@ -1100,6 +1118,9 @@ describe('Agent Database Activities Integration', () => {
provider: 'openai',
model: 'gpt-4',
},
skills: {
create: [{ skillId: enabledSkill.id }],
},
},
})
@@ -1110,6 +1131,10 @@ describe('Agent Database Activities Integration', () => {
expect(chatCtx.agent.id).toBe(agent.id)
expect(chatCtx.dbProviders[0].name).toBe('openai')
// Only the enabled skill must be advertised, and disabled team skills excluded
expect(chatCtx.teamSkills.map((s) => s.id)).toEqual([enabledSkill.id])
expect(chatCtx.enabledSkillIds).toEqual([enabledSkill.id])
expect(chatCtx.teamSkills.map((s) => s.id)).not.toContain(disabledSkill.id)
// Create User for autofill agent
const autofillUser = await prisma.user.create({
@@ -1132,6 +1157,9 @@ describe('Agent Database Activities Integration', () => {
provider: 'openai',
model: 'gpt-4',
},
skills: {
create: [{ skillId: enabledSkill.id }],
},
},
})
@@ -1140,6 +1168,77 @@ describe('Agent Database Activities Integration', () => {
})
expect(autofillCtx.agent.id).toBe(autofillAgent.id)
// Only the enabled skill must be advertised for the autofill agent as well
expect(autofillCtx.teamSkills.map((s) => s.id)).toEqual([enabledSkill.id])
expect(autofillCtx.enabledSkillIds).toEqual([enabledSkill.id])
expect(autofillCtx.teamSkills.map((s) => s.id)).not.toContain(disabledSkill.id)
})
it('should return an empty enabled skill list when the agent has no skills enabled', async () => {
const provider = await prisma.provider.create({
data: {
teamId: team.id,
name: 'openai-noskill',
config: {
api: 'openai-completions',
apiKey: 'mock-key',
},
},
})
const model = await prisma.model.create({
data: {
providerId: provider.id,
modelId: 'gpt-4',
name: 'GPT 4',
config: {
reasoning: false,
input: ['text'],
contextWindow: 8192,
maxTokens: 2048,
cost: { input: 0.01, output: 0.03, cacheRead: 0, cacheWrite: 0 },
},
},
})
await prisma.skill.create({
data: {
name: 'Team Wide Skill',
assetId: 'asset-team',
hash: 'team-hash',
teamId: team.id,
},
})
const agentUser = await prisma.user.create({
data: {
name: 'No Skill Agent User',
email: 'noskillagent@shumai.ai',
type: 'agent',
},
})
const agent = await prisma.agent.create({
data: {
id: agentUser.id,
teamId: team.id,
type: 'chat',
providerId: provider.id,
modelId: model.id,
config: {
provider: 'openai-noskill',
model: 'gpt-4',
},
},
})
const chatCtx = await getAgentChatContextActivity({
teamId: team.id,
agentId: agent.id,
})
// Team-wide skill exists but is not enabled for this agent
expect(chatCtx.teamSkills).toEqual([])
expect(chatCtx.enabledSkillIds).toEqual([])
})
})
@@ -1342,6 +1441,54 @@ describe('Agent Database Activities Integration', () => {
expect(res.assets.length).toBe(1)
expect(res.pageInfo.cursor).toBeDefined()
})
it('should resolve version_stack name and size from top child version when container name is empty', async () => {
const folder = await prisma.asset.create({
data: {
name: 'WorkspaceFolder',
type: AssetType.folder,
status: AssetStatus.uploaded,
projectId: project.id,
},
})
const versionStack = await prisma.asset.create({
data: {
name: '',
type: AssetType.version_stack,
status: AssetStatus.uploaded,
projectId: project.id,
parentId: folder.id,
},
})
await prisma.asset.create({
data: {
name: 'banana_ghost.txt',
type: AssetType.file,
status: AssetStatus.uploaded,
projectId: project.id,
parentId: versionStack.id,
sizeByte: 622960,
sortIndex: '0|i00000:',
},
})
const res = await executeAgentToolActivity({
taskId: 'task-1',
toolName: 'list_assets',
args: { parent: folder.id, page: 1, pageSize: 10 },
userId: user.id,
})
const stackItem = res.assets.find(
(a: { id: string; name: string; size: number; type: string }) => a.id === versionStack.id,
)
expect(stackItem).toBeDefined()
expect(stackItem?.name).toBe('banana_ghost.txt')
expect(stackItem?.size).toBe(622960)
expect(stackItem?.type).toBe('version_stack')
})
})
describe('create_folder', () => {
+85 -18
View File
@@ -7,6 +7,7 @@ import { type ImageContent } from '@earendil-works/pi-ai'
import { assetService } from '@shumai/core/src/asset/asset'
import { authzService, Permission, ResourceType } from '@shumai/core/src/authz/authz'
import { logger } from '@shumai/core/src/logger'
import { mcpService } from '@shumai/core/src/mcp/mcp-service'
import { metadataService } from '@shumai/core/src/metadata/metadata'
import { encodeCursor, paginateQuery } from '@shumai/core/src/pagination'
import { s3Service } from '@shumai/core/src/s3/s3'
@@ -41,6 +42,11 @@ export type AgentWithProviderAndModel = Prisma.AgentGetPayload<{
include: {
provider: true
modelRef: true
skills: {
include: {
skill: true
}
}
}
}>
@@ -54,6 +60,8 @@ export interface AgentExecutionContext {
agent: AgentWithProviderAndModel
dbProviders: DbProviderWithModels[]
teamSkills: Skill[]
mcpServers: Prisma.McpServerGetPayload<Record<string, never>>[]
enabledSkillIds: string[]
allowedDomains: string[]
}
@@ -71,7 +79,7 @@ async function executeAgentPrompt(params: {
context: AgentExecutionContext
attachedAssets?: Array<{ id: string; name: string; type: string }>
}): Promise<{ text: string; usage: Usage; sessionId: string }> {
const { agent, dbProviders, teamSkills, allowedDomains } = params.context
const { agent, dbProviders, teamSkills, enabledSkillIds, allowedDomains } = params.context
if (!agent.provider) {
throw ApplicationFailure.create({
@@ -96,7 +104,7 @@ shumai has its own cloud file system. If a user asks you to perform file system
If you need to create files in the local filesystem (for example, a temporary file for uploading), only the '.pi' folder in the current directory has write permissions. Do NOT attempt to create files in any other directories.
When creating a file or version, first use 'list_autofill_fields' to inspect the project's AI-autofillable metadata fields. If relevant metadata depends on information unavailable from the file content (for example, the AI model or tool used to generate it), include a brief context hint (maximum 50 words) in the 'context' field of 'create_file' or 'create_version' tool.`
When creating a file or version, first use 'list_autofill_fields' to inspect the project's AI-autofillable metadata fields. If relevant metadata depends on information unavailable from the file content (for example, the AI model or prompt used to generate the asset), include a context in the 'context' field of 'create_file' or 'create_version'. Keep the context short and only include information relevant to those fields.`
if (agent.soul) {
systemPrompt = `${systemPrompt}\n\nAgent Personality and Core Instructions:\n${agent.soul}`
@@ -113,6 +121,13 @@ When creating a file or version, first use 'list_autofill_fields' to inspect the
const agentConfig = agent.config as PrismaJson.AgentConfig | null | undefined
const thinkingLevel = agentConfig?.thinkingLevel || 'off'
// MCP tools are only wired to chat agents (D6); autofill/embedding/naming
// sessions never receive MCP tools even if a server is assigned.
const mcpTools =
agent.type === 'chat'
? await mcpService.buildAgentTools(params.agentId, params.teamId, params.userId)
: []
const { session, harness } = await createAgentSession({
teamId: params.teamId,
agentId: params.agentId,
@@ -125,11 +140,12 @@ When creating a file or version, first use 'list_autofill_fields' to inspect the
name: s.name,
description: s.description,
})),
enabledSkillIds,
allowedDomains,
sessionId: params.sessionId,
userId: params.userId,
userCommentId: params.userCommentId,
customTools: params.tools || [],
customTools: [...(params.tools || []), ...mcpTools],
providers: dbProviders.map((p) => ({
name: p.name,
config: p.config,
@@ -834,6 +850,11 @@ export async function getAgentChatContextActivity(params: {
include: {
provider: true,
modelRef: true,
skills: {
include: {
skill: true,
},
},
},
})
if (!agent) {
@@ -864,10 +885,17 @@ export async function getAgentChatContextActivity(params: {
include: { models: true },
})
// Fetch team skills
const teamSkills = await prisma.skill.findMany({
where: { teamId: params.teamId },
// Only advertise skills that are explicitly enabled for this agent (agent_skills).
// Disabled skills must not be listed in the system prompt nor loadable via read_skill.
const enabledSkills = (agent.skills ?? []).map((as) => as.skill)
const enabledSkillIds = enabledSkills.map((s) => s.id)
// Fetch the agent's assigned MCP servers
const assignments = await prisma.agentMcpServer.findMany({
where: { agentId: params.agentId },
include: { mcpServer: true },
})
const mcpServers = assignments.map((a) => a.mcpServer)
const sandbox = await prisma.sandbox.findUnique({
where: { teamId: params.teamId },
@@ -877,7 +905,9 @@ export async function getAgentChatContextActivity(params: {
return {
agent,
dbProviders,
teamSkills,
teamSkills: enabledSkills,
mcpServers,
enabledSkillIds,
allowedDomains,
}
}
@@ -912,6 +942,11 @@ export async function getAgentAutofillContextActivity(params: {
include: {
provider: true,
modelRef: true,
skills: {
include: {
skill: true,
},
},
},
})
if (!agentWithDetails) {
@@ -938,10 +973,13 @@ export async function getAgentAutofillContextActivity(params: {
include: { models: true },
})
// Fetch team skills
const teamSkills = await prisma.skill.findMany({
where: { teamId: params.teamId },
})
// Only advertise skills that are explicitly enabled for this agent (agent_skills).
// Disabled skills must not be listed in the system prompt nor loadable via read_skill.
const enabledSkills = (agentWithDetails.skills ?? []).map((as) => as.skill)
const enabledSkillIds = enabledSkills.map((s) => s.id)
// Autofill agents currently do not use MCP tools.
const mcpServers: Prisma.McpServerGetPayload<Record<string, never>>[] = []
const sandbox = await prisma.sandbox.findUnique({
where: { teamId: params.teamId },
@@ -951,7 +989,9 @@ export async function getAgentAutofillContextActivity(params: {
return {
agent: agentWithDetails,
dbProviders,
teamSkills,
teamSkills: enabledSkills,
mcpServers,
enabledSkillIds,
allowedDomains,
}
}
@@ -1134,13 +1174,40 @@ export async function executeAgentToolActivity(params: ExecuteAgentToolParams):
{ first: limit, after },
)
const stackIds = assets
.filter((a) => a.type === AssetType.version_stack && (!a.name || a.name === ''))
.map((a) => a.id)
const latestVersionsMap = new Map<string, Prisma.AssetGetPayload<Record<string, never>>>()
if (stackIds.length > 0) {
const versions = await prisma.asset.findMany({
where: { parentId: { in: stackIds }, isDeleted: false },
orderBy: { sortIndex: 'asc' },
})
for (const v of versions) {
if (!latestVersionsMap.has(v.parentId!)) {
latestVersionsMap.set(v.parentId!, v)
}
}
}
// return asset id, asset name, asset type, asset size (sizeByte or size)
const results = assets.map((a) => ({
id: a.id,
name: a.name,
type: a.type,
size: Number(a.sizeByte),
}))
const results = assets.map((a) => {
const latestVersion = latestVersionsMap.get(a.id)
return {
id: a.id,
name:
a.type === AssetType.version_stack && (!a.name || a.name === '')
? (latestVersion?.name ?? a.name)
: a.name,
type: a.type,
size:
a.type === AssetType.version_stack && latestVersion
? Number(latestVersion.sizeByte)
: Number(a.sizeByte),
}
})
return {
assets: results,
+146
View File
@@ -813,3 +813,149 @@ describe('createAgentSession bash restriction for non-owner users', () => {
expect(prompt).not.toContain('# Restricted User Context')
})
})
describe('createAgentSession enabled skill filtering', () => {
setupTestDbHooks()
afterEach(() => {
vi.restoreAllMocks()
})
it('should only advertise and allow reading skills enabled for the agent', async () => {
const team = await prisma.team.create({ data: { name: 'Skill Filter Team' } })
const enabledSkill = await prisma.skill.create({
data: {
name: 'Enabled Skill',
assetId: 'asset-enabled',
hash: 'enabled-hash',
teamId: team.id,
},
})
const disabledSkill = await prisma.skill.create({
data: {
name: 'Disabled Skill',
assetId: 'asset-disabled',
hash: 'disabled-hash',
teamId: team.id,
},
})
await prisma.user.create({
data: {
id: 'skill-filter-agent',
name: 'Ai Agent Skill Filter',
email: 'skill-filter-agent@shumai.ai',
type: 'agent',
},
})
await prisma.agent.create({
data: {
id: 'skill-filter-agent',
teamId: team.id,
type: 'chat',
config: { provider: 'google', model: 'gemini' },
skills: {
create: [{ skillId: enabledSkill.id }],
},
},
})
const initializeSpy = vi.spyOn(SandboxManager, 'initialize').mockResolvedValue()
try {
const { harness } = await createAgentSession({
teamId: team.id,
agentId: 'skill-filter-agent',
providerName: 'google',
modelId: 'gemini',
systemPrompt: 'prompt',
teamSkills: [{ id: enabledSkill.id, name: enabledSkill.name }],
enabledSkillIds: [enabledSkill.id],
allowedDomains: [],
providers: mockProviders,
})
// The disabled skill must not be advertised in the available skills list
// @ts-expect-error accessing private property for verification
const prompt = await harness.systemPrompt()
expect(prompt).toContain(enabledSkill.id)
expect(prompt).not.toContain(disabledSkill.id)
// read_skill must reject the disabled skill id
const readSkillTool = harness.getTools().find((t) => t.name === 'read_skill')
expect(readSkillTool).toBeDefined()
vi.spyOn(fs, 'existsSync').mockReturnValue(true)
// eslint-disable-next-line @typescript-eslint/no-explicit-any -- mocking node fs readFileSync which has complex overloaded signatures
vi.spyOn(fs, 'readFileSync').mockImplementation((p: any) => {
if (p.toString().endsWith('.hash')) return 'enabled-hash'
if (p.toString().endsWith('SKILL.md')) return '# Enabled Skill'
return ''
})
await expect(
readSkillTool!.execute('1', { skillId: disabledSkill.id }, undefined, undefined, undefined),
).rejects.toThrow('not enabled for this agent')
const result = await readSkillTool!.execute(
'1',
{ skillId: enabledSkill.id },
undefined,
undefined,
undefined,
)
// eslint-disable-next-line @typescript-eslint/no-explicit-any
expect((result.content[0] as any).text).toBe('# Enabled Skill')
} finally {
initializeSpy.mockRestore()
}
})
it('should reject all read_skill calls when no skills are enabled for the agent', async () => {
const team = await prisma.team.create({ data: { name: 'Skill None Team' } })
const skill = await prisma.skill.create({
data: { name: 'Unassigned Skill', assetId: 'asset-none', hash: 'none-hash', teamId: team.id },
})
await prisma.user.create({
data: {
id: 'skill-none-agent',
name: 'Ai Agent Skill None',
email: 'skill-none-agent@shumai.ai',
type: 'agent',
},
})
await prisma.agent.create({
data: {
id: 'skill-none-agent',
teamId: team.id,
type: 'chat',
config: { provider: 'google', model: 'gemini' },
},
})
const initializeSpy = vi.spyOn(SandboxManager, 'initialize').mockResolvedValue()
try {
const { harness } = await createAgentSession({
teamId: team.id,
agentId: 'skill-none-agent',
providerName: 'google',
modelId: 'gemini',
systemPrompt: 'prompt',
teamSkills: [],
enabledSkillIds: [],
allowedDomains: [],
providers: mockProviders,
})
const readSkillTool = harness.getTools().find((t) => t.name === 'read_skill')
expect(readSkillTool).toBeDefined()
await expect(
readSkillTool!.execute('1', { skillId: skill.id }, undefined, undefined, undefined),
).rejects.toThrow('not enabled for this agent')
} finally {
initializeSpy.mockRestore()
}
})
})
+8 -1
View File
@@ -98,6 +98,7 @@ export interface CreateAgentSessionParams {
modelId: string
systemPrompt: string
teamSkills: Array<{ id: string; name: string; description?: string | null }>
enabledSkillIds?: string[]
allowedDomains: string[]
sessionId?: string
userId?: string
@@ -145,6 +146,7 @@ export async function createAgentSession(params: CreateAgentSessionParams) {
modelId,
systemPrompt,
teamSkills,
enabledSkillIds,
allowedDomains,
sessionId,
userId,
@@ -313,7 +315,12 @@ export async function createAgentSession(params: CreateAgentSessionParams) {
next.map((t) => t.name),
)
}
const readSkill = createReadSkillTool(userId, onEnvsAdded, restricted ? onSkillLoaded : undefined)
const readSkill = createReadSkillTool(
userId,
onEnvsAdded,
restricted ? onSkillLoaded : undefined,
enabledSkillIds,
)
const systemTools: AgentTool[] = []
if (userId) {
+12 -1
View File
@@ -36,7 +36,7 @@ export function createAnalyzeImageTool(
id: assetId,
})
const asset = await prisma.asset.findUnique({
let asset = await prisma.asset.findUnique({
where: { id: assetId },
include: { storageKey: true },
})
@@ -45,6 +45,17 @@ export function createAnalyzeImageTool(
throw new Error(`Asset with ID ${assetId} not found.`)
}
if (asset.type === 'version_stack') {
const latestVersion = await prisma.asset.findFirst({
where: { parentId: asset.id, isDeleted: false },
orderBy: { sortIndex: 'asc' },
include: { storageKey: true },
})
if (latestVersion) {
asset = latestVersion
}
}
// Get default media key
let mediaKey = asset.storageKey?.key
if (asset.media) {
+4 -3
View File
@@ -33,9 +33,10 @@ const createFileSchema = Type.Object({
context: Type.Optional(
Type.String({
description:
'Optional short context about this file and how it was generated (max 50 words, e.g. "Generated using gemini"). ' +
'Passed to the AI metadata autofill workflow to fill fields that cannot be determined from file content alone. ' +
'Check autofillable fields with list_autofill_fields first.',
'Optional context passed to the AI metadata autofill workflow for fields that cannot be inferred from file content alone ' +
'(e.g. the model or prompt used to generate the asset). ' +
'Use list_autofill_fields first to check which fields can be autofilled. ' +
'Keep the context short and only include information relevant to those fields.',
}),
),
})
+4 -3
View File
@@ -20,9 +20,10 @@ const createVersionSchema = Type.Object({
context: Type.Optional(
Type.String({
description:
'Optional short context about this version and how it was generated (max 50 words, e.g. "Generated using gemini"). ' +
'Passed to the AI metadata autofill workflow to fill fields that cannot be determined from file content alone. ' +
'Check autofillable fields with list_autofill_fields first.',
'Optional context passed to the AI metadata autofill workflow for fields that cannot be inferred from file content alone ' +
'(e.g. the model or prompt used to generate the asset). ' +
'Use list_autofill_fields first to check which fields can be autofilled. ' +
'Keep the context short and only include information relevant to those fields.',
}),
),
})
@@ -13,6 +13,7 @@ vi.mock('@shumai/db', async (importOriginal) => {
prisma: {
asset: {
findUnique: vi.fn(),
findFirst: vi.fn(),
},
},
}
@@ -166,4 +167,48 @@ describe('downloadAssetTool', () => {
expect(fs.existsSync(expectedPath)).toBe(true)
expect(result.details.contentType).toBe('text/markdown')
})
it('should resolve version_stack asset to its latest version file', async () => {
vi.mocked(authzService.hasPermission).mockResolvedValue()
vi.mocked(prisma.asset.findUnique).mockResolvedValue({
id: 'stack-1',
name: '',
type: 'version_stack',
storageKey: null,
media: null,
} as unknown as Asset)
vi.mocked(prisma.asset.findFirst).mockResolvedValue({
id: 'file-ver-2',
name: 'banana_pig.png',
type: 'file',
storageKey: { key: 'raw/banana_pig.png' },
media: {
proxyType: 'image',
imageTranscodes: [{ key: 'proxy/banana_pig.webp' }],
},
} as unknown as Asset)
vi.mocked(s3Service.getObject).mockResolvedValue({
buffer: Buffer.from('fake-version-bytes'),
contentType: 'image/webp',
} as unknown as { buffer: Buffer; contentType: string })
const tool = createDownloadAssetTool('user-1')
const result = await tool.execute('call-1', { assetId: 'stack-1' })
expect(prisma.asset.findFirst).toHaveBeenCalledWith({
where: { parentId: 'stack-1', isDeleted: false },
orderBy: { sortIndex: 'asc' },
include: { storageKey: true },
})
expect(s3Service.getObject).toHaveBeenCalledWith('shumai', 'proxy/banana_pig.webp')
const expectedPath = path.join(piDir, 'file-ver-2_banana_pig.png')
createdFiles.push(expectedPath)
expect(fs.existsSync(expectedPath)).toBe(true)
expect(result.details.name).toBe('banana_pig.png')
})
})
+12 -1
View File
@@ -35,7 +35,7 @@ export function createDownloadAssetTool(userId: string): AgentTool<typeof downlo
id: assetId,
})
const asset = await prisma.asset.findUnique({
let asset = await prisma.asset.findUnique({
where: { id: assetId },
include: { storageKey: true },
})
@@ -44,6 +44,17 @@ export function createDownloadAssetTool(userId: string): AgentTool<typeof downlo
throw new Error(`Asset with ID ${assetId} not found.`)
}
if (asset.type === 'version_stack') {
const latestVersion = await prisma.asset.findFirst({
where: { parentId: asset.id, isDeleted: false },
orderBy: { sortIndex: 'asc' },
include: { storageKey: true },
})
if (latestVersion) {
asset = latestVersion
}
}
let mediaKey = asset.storageKey?.key
if (asset.media) {
@@ -17,7 +17,7 @@ export function createListAutofillFieldsTool(
label: 'List Autofill Fields',
description:
'List the AI-autofillable metadata fields defined for the project of a parent folder, including their types and available options. ' +
'Use this before creating a file or version so you can pass relevant context (e.g. generation source) to create_file/create_version.',
'Use this before creating a file or version so you can pass relevant context (e.g. the model or prompt used to generate the asset) to create_file/create_version.',
parameters: listAutofillFieldsSchema,
execute: async (_toolCallId, params) => {
const result = await executeAgentToolWorkflow({
+11 -1
View File
@@ -56,7 +56,7 @@ export function createReadPdfPagesTool(
id: targetAssetId,
})
const asset = await prisma.asset.findUnique({
let asset = await prisma.asset.findUnique({
where: { id: targetAssetId },
})
@@ -64,6 +64,16 @@ export function createReadPdfPagesTool(
throw new Error(`Asset with ID ${targetAssetId} not found.`)
}
if (asset.type === 'version_stack') {
const latestVersion = await prisma.asset.findFirst({
where: { parentId: asset.id, isDeleted: false },
orderBy: { sortIndex: 'asc' },
})
if (latestVersion) {
asset = latestVersion
}
}
const proxyType = (asset.media as PrismaJson.MediaInfo | null)?.proxyType
if (proxyType !== 'pdf') {
throw new Error(`Asset ${targetAssetId} is not a PDF or document.`)
@@ -363,4 +363,75 @@ describe('readSkillTool', () => {
expect(onSkillLoaded).not.toHaveBeenCalled()
})
})
describe('enabled skills enforcement', () => {
it('should reject loading a skill that is not enabled for the agent', async () => {
const team = await prisma.team.create({ data: { name: 'Enabled Filter Team' } })
const skill = await prisma.skill.create({
data: {
name: 'Disabled For Agent Skill',
assetId: 'asset1',
hash: 'disabled-agent-hash',
teamId: team.id,
},
})
const readSkillTool = createReadSkillTool(undefined, () => {}, undefined, [
'some-other-enabled-skill',
])
await expect(
readSkillTool.execute('1', { skillId: skill.id }, undefined, undefined),
).rejects.toThrow('not enabled for this agent')
})
it('should allow loading a skill that is enabled for the agent', async () => {
const team = await prisma.team.create({ data: { name: 'Enabled Allow Team' } })
const skill = await prisma.skill.create({
data: {
name: 'Enabled For Agent Skill',
assetId: 'asset1',
hash: 'enabled-agent-hash',
teamId: team.id,
},
})
vi.spyOn(fs, 'existsSync').mockReturnValue(true)
// eslint-disable-next-line @typescript-eslint/no-explicit-any -- mocking node fs readFileSync which has complex overloaded signatures
vi.spyOn(fs, 'readFileSync').mockImplementation((path: any) => {
if (path.toString().endsWith('.hash')) return 'enabled-agent-hash'
if (path.toString().endsWith('SKILL.md')) return '# Enabled For Agent Skill'
return ''
})
const readSkillTool = createReadSkillTool(undefined, () => {}, undefined, [skill.id])
const result = await readSkillTool.execute('1', { skillId: skill.id }, undefined, undefined)
// eslint-disable-next-line @typescript-eslint/no-explicit-any
expect((result.content[0] as any).text).toBe('# Enabled For Agent Skill')
})
it('should allow loading any skill when enabledSkillIds is not provided (backward compatibility)', async () => {
const team = await prisma.team.create({ data: { name: 'No Filter Team' } })
const skill = await prisma.skill.create({
data: {
name: 'No Filter Skill',
assetId: 'asset1',
hash: 'no-filter-hash',
teamId: team.id,
},
})
vi.spyOn(fs, 'existsSync').mockReturnValue(true)
// eslint-disable-next-line @typescript-eslint/no-explicit-any -- mocking node fs readFileSync which has complex overloaded signatures
vi.spyOn(fs, 'readFileSync').mockImplementation((path: any) => {
if (path.toString().endsWith('.hash')) return 'no-filter-hash'
if (path.toString().endsWith('SKILL.md')) return '# No Filter Skill'
return ''
})
const readSkillTool = createReadSkillTool(undefined, () => {})
const result = await readSkillTool.execute('1', { skillId: skill.id }, undefined, undefined)
// eslint-disable-next-line @typescript-eslint/no-explicit-any
expect((result.content[0] as any).text).toBe('# No Filter Skill')
})
})
})
+7
View File
@@ -17,6 +17,7 @@ export const createReadSkillTool = (
userId: string | undefined,
onEnvsAdded: (envs: Record<string, string>) => void,
onSkillLoaded?: () => Promise<void> | void,
enabledSkillIds?: string[],
): AgentTool<typeof readSkillSchema, { skillId: string }> => ({
name: 'read_skill',
label: 'Read Agent Skill',
@@ -31,6 +32,12 @@ export const createReadSkillTool = (
throw new Error(`Skill with ID ${params.skillId} not found.`)
}
// Skills disabled for this agent must not be loadable, even if the model
// somehow knows their ID (e.g. from earlier conversation history).
if (enabledSkillIds && !enabledSkillIds.includes(params.skillId)) {
throw new Error(`Skill with ID ${params.skillId} is not enabled for this agent.`)
}
const requiredLevel = ROLE_HIERARCHY[skill.permission] || 1
if (userId) {
@@ -186,7 +186,7 @@ describe('Agent Embedding Workflow', () => {
mediaType: 'image/png',
storageKey: { key: 'test.png' },
media: {
imageTranscodes: [{ key: 'test-transcoded.webp', isRaw: false, format: 'webp' }],
imageTranscodes: [{ key: 'test-transcoded.webp', format: 'webp' }],
},
},
chunkDuration: 60.0,
@@ -220,7 +220,7 @@ describe('Agent Embedding Workflow', () => {
storageKey: { key: 'test.mp4' },
media: {
duration: 150.0,
videoTranscodes: [{ key: 'test-transcoded.mp4', isRaw: false }],
videoTranscodes: [{ key: 'test-transcoded.mp4' }],
},
},
chunkDuration: 60.0,
@@ -91,20 +91,14 @@ export async function agentEmbeddingMedia(task: WorkflowTask): Promise<void> {
const media = asset.media as any
if (isVideo) {
if (media.videoTranscodes && media.videoTranscodes.length > 0) {
// Find first non-raw transcode or fallback to first transcode
const transcode =
media.videoTranscodes.find((t: PrismaJson.VideoTranscode) => !t.isRaw) ||
media.videoTranscodes[0]
const transcode = media.videoTranscodes[0] as PrismaJson.VideoTranscode
if (transcode?.key) {
embeddingKey = transcode.key
}
}
} else if (isImage) {
if (media.imageTranscodes && media.imageTranscodes.length > 0) {
// Find first non-raw transcode or fallback to first transcode
const transcode =
media.imageTranscodes.find((t: PrismaJson.ImageTranscode) => !t.isRaw) ||
media.imageTranscodes[0]
const transcode = media.imageTranscodes[0] as PrismaJson.ImageTranscode
if (transcode?.key) {
embeddingKey = transcode.key
if (transcode.format) {
+1 -1
View File
@@ -1,6 +1,6 @@
{
"name": "@shumai/api",
"version": "0.3.3",
"version": "0.3.6",
"private": true,
"type": "module",
"main": "./src/index.ts",
+3
View File
@@ -50,6 +50,7 @@ const route = new Hono<{ Variables: { user: User } }>()
skillId: s.skillId,
skill: s.skill,
})),
mcpServerIds: (agent.mcpServers || []).map((m) => m.mcpServerId),
deniedTools: config.deniedTools || [],
}
}),
@@ -93,6 +94,7 @@ const route = new Hono<{ Variables: { user: User } }>()
skillId: s.skillId,
skill: s.skill,
})),
mcpServerIds: (agent.mcpServers || []).map((m) => m.mcpServerId),
deniedTools: config.deniedTools || [],
}
@@ -146,6 +148,7 @@ const route = new Hono<{ Variables: { user: User } }>()
skillId: s.skillId,
skill: s.skill,
})),
mcpServerIds: (agent.mcpServers || []).map((m) => m.mcpServerId),
deniedTools: config.deniedTools || [],
}
+2 -1
View File
@@ -351,7 +351,8 @@ const route = new Hono<{ Variables: { user: User } }>()
contentType,
)
return c.json({ key })
const url = await s3Service.presign(process.env.S3_BUCKET || 'shumai', key, 'GET')
return c.json({ key, url })
})
.post('/files/download-links', zValidator('json', getDownloadLinksRequestSchema), async (c) => {
const user = c.get('user')
+5
View File
@@ -9,6 +9,7 @@ import fileRoute from './file'
import folderRoute from './folder'
import inviteRoute from './invite'
import metadataRoute from './metadata'
import mcpRoute, { mcpOauthCallbackRoute } from './mcp'
import { authMiddleware } from './middleware/auth'
import { tokenAuthMiddleware } from './middleware/tokenAuth'
import notificationRoute from './notification'
@@ -19,6 +20,7 @@ import publicShareRoute from './public-share'
import s3Route from './s3'
import shareRoute from './share'
import skillRoute from './skill'
import watermarkTemplateRoute from './watermark-template'
import teamRoute from './team'
import uploadRoute, { localUploadRoute } from './upload'
import versionStackRoute from './versionStack'
@@ -33,6 +35,7 @@ const apiRoute = new Hono<{ Variables: { user: User } }>()
.route('/', publicInviteRoute)
.route('/', publicShareRoute)
.route('/', localUploadRoute)
.route('/', mcpOauthCallbackRoute)
// Selected routes supporting API token authentication
.use('/projects', tokenAuthMiddleware)
@@ -60,6 +63,8 @@ const apiRoute = new Hono<{ Variables: { user: User } }>()
.route('/', uploadRoute)
.route('/', shareRoute)
.route('/', skillRoute)
.route('/', mcpRoute)
.route('/', watermarkTemplateRoute)
app.route('/files', s3Route)
+351
View File
@@ -0,0 +1,351 @@
import { describe, expect, test, vi, beforeEach } from 'vitest'
import { Hono } from 'hono'
import mcpRoute, { mcpOauthCallbackRoute } from './mcp'
import { mcpService } from '@shumai/core/src/mcp/mcp-service'
import { authMiddleware } from './middleware/auth'
import { authzService, ResourceType, Permission } from '@shumai/core/src/authz/authz'
import { auditLogService } from '@shumai/core/src/auditLog/auditLog'
vi.mock('@shumai/core/src/auditLog/auditLog', () => ({
auditLogService: {
logAction: vi.fn().mockResolvedValue({}),
},
}))
vi.mock('@shumai/core/src/mcp/mcp-service', () => ({
mcpService: {
listServers: vi.fn(),
createServer: vi.fn(),
getServer: vi.fn(),
getServerRecord: vi.fn(),
updateServer: vi.fn(),
updateServerPermission: vi.fn(),
deleteServer: vi.fn(),
refreshServer: vi.fn(),
startAuth: vi.fn(),
completeAuth: vi.fn(),
getAuthStatus: vi.fn(),
removeAuth: vi.fn(),
testServer: vi.fn(),
handleOauthCallback: vi.fn(),
},
}))
vi.mock('./middleware/auth', () => ({
// eslint-disable-next-line @typescript-eslint/no-explicit-any
authMiddleware: async (c: any, next: any) => {
// eslint-disable-next-line @typescript-eslint/no-explicit-any
c.set('user', { id: 'user1', name: 'Test User' } as any)
await next()
},
}))
vi.mock('@shumai/core/src/authz/authz', () => ({
authzService: {
hasPermission: vi.fn().mockResolvedValue(undefined),
},
Permission: {
Read: 'Read',
Edit: 'Edit',
Admin: 'Admin',
},
ResourceType: {
Team: 'team',
McpServer: 'mcpServer',
},
}))
import type { McpServerInfo } from '@shumai/dtos'
const serverInfo: McpServerInfo = {
id: 'server1',
name: 'github',
description: 'GitHub MCP server',
instructions: 'Always use the sandbox API and respect rate limits.',
url: 'https://mcp.example.com/github',
transport: 'streamable_http',
authType: 'bearer',
permission: 'reviewer',
status: 'not_connected',
toolCount: 0,
hasCredential: false,
createdAt: new Date().toISOString(),
updatedAt: new Date().toISOString(),
}
describe('MCP API', () => {
const app = new Hono().use('*', authMiddleware).route('/', mcpRoute)
beforeEach(() => {
vi.restoreAllMocks()
// Clear call history so per-test call assertions are isolated.
vi.clearAllMocks()
vi.mocked(authzService.hasPermission).mockResolvedValue(undefined)
vi.mocked(mcpService.listServers).mockResolvedValue([serverInfo])
vi.mocked(mcpService.getServer).mockResolvedValue(serverInfo)
vi.mocked(mcpService.getServerRecord).mockResolvedValue({
...serverInfo,
lastError: null,
lastConnectedAt: null,
teamId: 'team1',
tools: [],
credential: null,
config: null,
authConfig: { type: 'bearer', bearerToken: 'secret' },
} as never)
})
test('lists servers with Admin permission on the team', async () => {
const res = await app.request('/teams/team1/mcp/servers')
expect(res.status).toBe(200)
expect(await res.json()).toEqual({ servers: [serverInfo] })
expect(authzService.hasPermission).toHaveBeenCalledWith({
user: expect.anything(),
permission: Permission.Admin,
type: ResourceType.Team,
id: 'team1',
})
})
test('includes server instructions in list and get responses', async () => {
const list = await app.request('/teams/team1/mcp/servers')
expect((await list.json()).servers[0].instructions).toBe(
'Always use the sandbox API and respect rate limits.',
)
const got = await app.request('/mcp/servers/server1')
expect((await got.json()).instructions).toBe(
'Always use the sandbox API and respect rate limits.',
)
})
test('creates a server and audits it', async () => {
vi.mocked(mcpService.createServer).mockResolvedValue(serverInfo)
const res = await app.request('/teams/team1/mcp/servers', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ url: 'https://mcp.example.com/github' }),
})
expect(res.status).toBe(200)
expect(await res.json()).toEqual(serverInfo)
expect(auditLogService.logAction).toHaveBeenCalledWith(
expect.objectContaining({ action: 'mcp_server_create', teamId: 'team1' }),
)
})
test('rejects a server with an invalid URL', async () => {
const res = await app.request('/teams/team1/mcp/servers', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ url: 'not-a-url' }),
})
expect(res.status).toBe(400)
expect(mcpService.createServer).not.toHaveBeenCalled()
})
test('gets a single server with Admin on the McpServer resource', async () => {
const res = await app.request('/mcp/servers/server1')
expect(res.status).toBe(200)
expect(await res.json()).toEqual(serverInfo)
expect(authzService.hasPermission).toHaveBeenCalledWith({
user: expect.anything(),
permission: Permission.Admin,
type: ResourceType.McpServer,
id: 'server1',
})
})
test('returns 404 when the server is missing', async () => {
vi.mocked(mcpService.getServer).mockResolvedValue(null)
const res = await app.request('/mcp/servers/missing')
expect(res.status).toBe(404)
})
test('updates a server and audits it', async () => {
vi.mocked(mcpService.updateServer).mockResolvedValue({
...serverInfo,
transport: 'sse',
})
const res = await app.request('/mcp/servers/server1', {
method: 'PATCH',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ transport: 'sse' }),
})
expect(res.status).toBe(200)
expect(await res.json()).toEqual({ ...serverInfo, transport: 'sse' })
expect(auditLogService.logAction).toHaveBeenCalledWith(
expect.objectContaining({ action: 'mcp_server_update', itemId: 'server1' }),
)
})
test('updates the permission via the dedicated route', async () => {
vi.mocked(mcpService.updateServerPermission).mockResolvedValue({
...serverInfo,
permission: 'editor',
})
const res = await app.request('/mcp/servers/server1/permission', {
method: 'PATCH',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ permission: 'editor' }),
})
expect(res.status).toBe(200)
expect(await res.json()).toEqual({ ...serverInfo, permission: 'editor' })
expect(mcpService.updateServerPermission).toHaveBeenCalledWith('server1', 'editor')
})
test('rejects an invalid permission value', async () => {
const res = await app.request('/mcp/servers/server1/permission', {
method: 'PATCH',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ permission: 'superadmin' }),
})
expect(res.status).toBe(400)
})
test('deletes a server and audits it', async () => {
const res = await app.request('/mcp/servers/server1', { method: 'DELETE' })
expect(res.status).toBe(204)
expect(auditLogService.logAction).toHaveBeenCalledWith(
expect.objectContaining({ action: 'mcp_server_delete', itemId: 'server1' }),
)
})
test('refreshes a server and returns the updated record', async () => {
vi.mocked(mcpService.refreshServer).mockResolvedValue({
...serverInfo,
status: 'connected',
toolCount: 3,
instructions: 'Always use the sandbox API and respect rate limits.',
})
const res = await app.request('/mcp/servers/server1/refresh', { method: 'POST' })
expect(res.status).toBe(200)
expect(await res.json()).toEqual({
...serverInfo,
status: 'connected',
toolCount: 3,
instructions: 'Always use the sandbox API and respect rate limits.',
})
})
test('refresh failure returns 502 with the error message', async () => {
vi.mocked(mcpService.refreshServer).mockRejectedValue(new Error('boom'))
const res = await app.request('/mcp/servers/server1/refresh', { method: 'POST' })
expect(res.status).toBe(502)
expect(await res.json()).toEqual({ error: 'boom' })
})
test('lists cached tools', async () => {
vi.mocked(mcpService.getServerRecord).mockResolvedValue({
...serverInfo,
lastError: null,
lastConnectedAt: null,
teamId: 'team1',
tools: [{ name: 'echo' }],
credential: null,
config: null,
authConfig: null,
} as never)
const res = await app.request('/mcp/servers/server1/tools')
expect(res.status).toBe(200)
expect(await res.json()).toEqual({ tools: [{ name: 'echo' }] })
})
test('starts OAuth auth', async () => {
vi.mocked(mcpService.startAuth).mockResolvedValue({
authorizationUrl: 'https://auth.example.com/authorize',
})
const res = await app.request('/mcp/servers/server1/auth/start', { method: 'POST' })
expect(res.status).toBe(200)
expect(await res.json()).toEqual({
authorizationUrl: 'https://auth.example.com/authorize',
status: 'in_progress',
})
})
test('completes OAuth auth', async () => {
vi.mocked(mcpService.completeAuth).mockResolvedValue('authenticated')
const res = await app.request('/mcp/servers/server1/auth/complete', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ code: 'auth-code', iss: 'https://issuer.example.com' }),
})
expect(res.status).toBe(200)
expect(await res.json()).toEqual({ status: 'authenticated' })
expect(mcpService.completeAuth).toHaveBeenCalledWith('server1', {
code: 'auth-code',
iss: 'https://issuer.example.com',
})
})
test('reports auth status', async () => {
vi.mocked(mcpService.getAuthStatus).mockResolvedValue('not_authenticated')
const res = await app.request('/mcp/servers/server1/auth/status')
expect(res.status).toBe(200)
expect(await res.json()).toEqual({ status: 'not_authenticated' })
})
test('removes auth', async () => {
const res = await app.request('/mcp/servers/server1/auth', { method: 'DELETE' })
expect(res.status).toBe(204)
expect(mcpService.removeAuth).toHaveBeenCalledWith('server1')
})
test('tests the server connection', async () => {
vi.mocked(mcpService.testServer).mockResolvedValue({ ok: true, toolCount: 3 })
const res = await app.request('/mcp/servers/server1/test', { method: 'POST' })
expect(res.status).toBe(200)
expect(await res.json()).toEqual({ ok: true, toolCount: 3 })
})
})
describe('MCP OAuth callback route', () => {
beforeEach(() => {
vi.clearAllMocks()
})
test('completes a valid callback and renders an HTML page', async () => {
vi.mocked(mcpService.handleOauthCallback).mockResolvedValue({ ok: true })
const res = await mcpOauthCallbackRoute.request(
'/mcp/oauth/callback?code=abc&state=xyz&iss=https%3A%2F%2Fissuer.example.com',
)
expect(res.status).toBe(200)
expect(res.headers.get('content-type')).toContain('text/html')
expect(mcpService.handleOauthCallback).toHaveBeenCalledWith(
'abc',
'xyz',
'https://issuer.example.com',
)
const body = await res.text()
expect(body).toContain('postMessage')
expect(body).toContain('"ok":true')
})
test('rejects a callback missing code or state', async () => {
const res = await mcpOauthCallbackRoute.request('/mcp/oauth/callback?code=abc')
expect(res.status).toBe(400)
expect(mcpService.handleOauthCallback).not.toHaveBeenCalled()
})
test('surfaces callback failures in the HTML page', async () => {
vi.mocked(mcpService.handleOauthCallback).mockResolvedValue({
ok: false,
message: 'Invalid or expired OAuth state',
})
const res = await mcpOauthCallbackRoute.request('/mcp/oauth/callback?code=abc&state=bad')
expect(res.status).toBe(200)
const body = await res.text()
expect(body).toContain('"ok":false')
expect(body).toContain('Invalid or expired OAuth state')
})
test('accepts POST callbacks (form-encoded)', async () => {
vi.mocked(mcpService.handleOauthCallback).mockResolvedValue({ ok: true })
const res = await mcpOauthCallbackRoute.request('/mcp/oauth/callback', {
method: 'POST',
headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
body: 'code=abc&state=xyz',
})
expect(res.status).toBe(200)
expect(mcpService.handleOauthCallback).toHaveBeenCalledWith('abc', 'xyz', undefined)
})
})
+356
View File
@@ -0,0 +1,356 @@
import { Hono } from 'hono'
import { zValidator } from '@hono/zod-validator'
import { authzService, Permission, ResourceType } from '@shumai/core/src/authz/authz'
import { mcpService } from '@shumai/core/src/mcp/mcp-service'
import {
createMcpServerRequestSchema,
updateMcpServerRequestSchema,
updateMcpServerPermissionRequestSchema,
mcpAuthCompleteRequestSchema,
AuditAction,
} from '@shumai/dtos'
import type { Prisma } from '@shumai/db'
import { auditLogService } from '@shumai/core/src/auditLog/auditLog'
type User = Prisma.UserGetPayload<Record<string, never>>
const route = new Hono<{ Variables: { user: User } }>()
.get('/teams/:teamId/mcp/servers', async (c) => {
const user = c.get('user')
const teamId = c.req.param('teamId')
await authzService.hasPermission({
user,
permission: Permission.Admin,
type: ResourceType.Team,
id: teamId,
})
const servers = await mcpService.listServers(teamId)
return c.json({ servers })
})
.post(
'/teams/:teamId/mcp/servers',
zValidator('json', createMcpServerRequestSchema),
async (c) => {
const user = c.get('user')
const teamId = c.req.param('teamId')
const req = c.req.valid('json')
await authzService.hasPermission({
user,
permission: Permission.Admin,
type: ResourceType.Team,
id: teamId,
})
const server = await mcpService.createServer(teamId, req)
await auditLogService.logAction({
action: AuditAction.mcp_server_create,
teamId,
userId: user?.id,
itemId: server.id,
})
return c.json(server)
},
)
.get('/mcp/servers/:id', async (c) => {
const user = c.get('user')
const id = c.req.param('id')
await authzService.hasPermission({
user,
permission: Permission.Admin,
type: ResourceType.McpServer,
id,
})
const server = await mcpService.getServer(id)
if (!server) return c.json({ error: 'MCP server not found' }, 404)
return c.json(server)
})
.patch('/mcp/servers/:id', zValidator('json', updateMcpServerRequestSchema), async (c) => {
const user = c.get('user')
const id = c.req.param('id')
const req = c.req.valid('json')
await authzService.hasPermission({
user,
permission: Permission.Admin,
type: ResourceType.McpServer,
id,
})
const existing = await mcpService.getServerRecord(id)
if (!existing) return c.json({ error: 'MCP server not found' }, 404)
const server = await mcpService.updateServer(id, req)
await auditLogService.logAction({
action: AuditAction.mcp_server_update,
teamId: existing.teamId,
userId: user?.id,
itemId: id,
})
return c.json(server)
})
.patch(
'/mcp/servers/:id/permission',
zValidator('json', updateMcpServerPermissionRequestSchema),
async (c) => {
const user = c.get('user')
const id = c.req.param('id')
const req = c.req.valid('json')
await authzService.hasPermission({
user,
permission: Permission.Admin,
type: ResourceType.McpServer,
id,
})
const existing = await mcpService.getServerRecord(id)
if (!existing) return c.json({ error: 'MCP server not found' }, 404)
const server = await mcpService.updateServerPermission(id, req.permission)
await auditLogService.logAction({
action: AuditAction.mcp_server_update,
teamId: existing.teamId,
userId: user?.id,
itemId: id,
})
return c.json(server)
},
)
.delete('/mcp/servers/:id', async (c) => {
const user = c.get('user')
const id = c.req.param('id')
await authzService.hasPermission({
user,
permission: Permission.Admin,
type: ResourceType.McpServer,
id,
})
const existing = await mcpService.getServerRecord(id)
await mcpService.deleteServer(id)
if (existing) {
await auditLogService.logAction({
action: AuditAction.mcp_server_delete,
teamId: existing.teamId,
userId: user?.id,
itemId: id,
})
}
return new Response(null, { status: 204 })
})
.post('/mcp/servers/:id/refresh', async (c) => {
const user = c.get('user')
const id = c.req.param('id')
await authzService.hasPermission({
user,
permission: Permission.Admin,
type: ResourceType.McpServer,
id,
})
try {
const server = await mcpService.refreshServer(id)
return c.json(server)
} catch (err) {
const message = err instanceof Error ? err.message : String(err)
return c.json({ error: message }, 502)
}
})
.get('/mcp/servers/:id/tools', async (c) => {
const user = c.get('user')
const id = c.req.param('id')
await authzService.hasPermission({
user,
permission: Permission.Admin,
type: ResourceType.McpServer,
id,
})
const server = await mcpService.getServer(id)
if (!server) return c.json({ error: 'MCP server not found' }, 404)
const record = await mcpService.getServerRecord(id)
return c.json({ tools: record?.tools ?? [] })
})
.post('/mcp/servers/:id/auth/start', async (c) => {
const user = c.get('user')
const id = c.req.param('id')
await authzService.hasPermission({
user,
permission: Permission.Admin,
type: ResourceType.McpServer,
id,
})
try {
const result = await mcpService.startAuth(id)
if (result.alreadyAuthenticated) {
return c.json({ status: 'authenticated' })
}
return c.json({ authorizationUrl: result.authorizationUrl, status: 'in_progress' })
} catch (err) {
const message = err instanceof Error ? err.message : String(err)
return c.json({ error: message }, 502)
}
})
.post(
'/mcp/servers/:id/auth/complete',
zValidator('json', mcpAuthCompleteRequestSchema),
async (c) => {
const user = c.get('user')
const id = c.req.param('id')
const req = c.req.valid('json')
await authzService.hasPermission({
user,
permission: Permission.Admin,
type: ResourceType.McpServer,
id,
})
try {
const status = await mcpService.completeAuth(id, { code: req.code, iss: req.iss })
return c.json({ status })
} catch (err) {
const message = err instanceof Error ? err.message : String(err)
return c.json({ error: message }, 502)
}
},
)
.get('/mcp/servers/:id/auth/status', async (c) => {
const user = c.get('user')
const id = c.req.param('id')
await authzService.hasPermission({
user,
permission: Permission.Admin,
type: ResourceType.McpServer,
id,
})
try {
const status = await mcpService.getAuthStatus(id)
return c.json({ status })
} catch (err) {
const message = err instanceof Error ? err.message : String(err)
return c.json({ error: message }, 404)
}
})
.delete('/mcp/servers/:id/auth', async (c) => {
const user = c.get('user')
const id = c.req.param('id')
await authzService.hasPermission({
user,
permission: Permission.Admin,
type: ResourceType.McpServer,
id,
})
await mcpService.removeAuth(id)
return new Response(null, { status: 204 })
})
.post('/mcp/servers/:id/test', async (c) => {
const user = c.get('user')
const id = c.req.param('id')
await authzService.hasPermission({
user,
permission: Permission.Admin,
type: ResourceType.McpServer,
id,
})
const result = await mcpService.testServer(id)
return c.json(result)
})
export default route
// ---------------------------------------------------------------------------
// Public OAuth callback route (mounted BEFORE authMiddleware in index.ts).
// The OAuth provider redirects the user's browser here after approval.
// ---------------------------------------------------------------------------
function renderCallbackPage(payload: { ok: boolean; message?: string }): string {
const escaped = JSON.stringify(payload).replace(/</g, '\\u003c')
return `<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8" />
<title>MCP OAuth</title>
</head>
<body>
<script>
(function () {
var payload = ${escaped};
try {
if (window.opener) {
window.opener.postMessage({ source: 'shumai-mcp-oauth', payload: payload }, '*');
}
} catch (e) {
/* ignore cross-origin postMessage failures */
}
setTimeout(function () {
window.close();
document.body.textContent = payload.ok ? 'Authentication complete. You can close this window.' : 'Authentication failed: ' + (payload.message || 'unknown error');
}, 300);
})();
</script>
</body>
</html>`
}
export const mcpOauthCallbackRoute = new Hono()
.get('/mcp/oauth/callback', async (c) => {
const code = c.req.query('code')
const state = c.req.query('state')
const iss = c.req.query('iss') || undefined
if (!code || !state) {
return c.html(
renderCallbackPage({ ok: false, message: 'Missing code or state parameter' }),
400,
)
}
const result = await mcpService.handleOauthCallback(code, state, iss)
return c.html(
renderCallbackPage(result.ok ? { ok: true } : { ok: false, message: result.message }),
)
})
.post('/mcp/oauth/callback', async (c) => {
const body = await c.req.parseBody()
const code = typeof body['code'] === 'string' ? body['code'] : undefined
const state = typeof body['state'] === 'string' ? body['state'] : undefined
const iss = typeof body['iss'] === 'string' ? body['iss'] : undefined
if (!code || !state) {
return c.html(
renderCallbackPage({ ok: false, message: 'Missing code or state parameter' }),
400,
)
}
const result = await mcpService.handleOauthCallback(code, state, iss)
return c.html(
renderCallbackPage(result.ok ? { ok: true } : { ok: false, message: result.message }),
)
})
+104 -3
View File
@@ -3,6 +3,7 @@ import type { Context } from 'hono'
import { zValidator } from '@hono/zod-validator'
import { shareService } from '@shumai/core/src/share/share'
import { assetService } from '@shumai/core/src/asset/asset'
import { watermarkService } from '@shumai/core/src/watermark/watermark'
import { paginationParamsSchema } from '@shumai/dtos'
import { z } from 'zod'
import { metadataService } from '@shumai/core/src/metadata/metadata'
@@ -18,7 +19,65 @@ import {
ShareLinkDisabledError,
ShareLinkExpiredError,
ShareLinkPasswordInvalidError,
ShareLinkDownloadDisabledError,
} from '@shumai/core/src/share/errors'
import { s3Service } from '@shumai/core/src/s3/s3'
import type { AssetInfo } from '@shumai/dtos'
/**
* Replaces the served media entries with the watermarked proxy entries produced
* by the watermark transcode activity. When no completed watermark proxy exists
* yet (still transcoding, or failed), the video/image transcode slots are emptied
* so original, unwatermarked proxies are never exposed on the public share.
*
* Only video/image assets are subject to watermark protection; other media types
* (pdf, audio, ...) never receive watermark transcodes and pass through untouched.
* `original`, `thumbnail` and `videoPreview` are intentionally left untouched here.
* S3 GET URLs are generated for all watermarked proxies.
*/
async function applyWatermarkToAssetMedia(
asset: AssetInfo,
watermarkMedia: PrismaJson.MediaInfo | null,
): Promise<AssetInfo> {
if (!asset.media) return asset
if (asset.proxyType !== 'video' && asset.proxyType !== 'image') return asset
const updatedMedia = { ...asset.media }
const bucket = process.env.S3_BUCKET || 'shumai'
updatedMedia.videoTranscodes =
watermarkMedia?.videoTranscodes && watermarkMedia.videoTranscodes.length > 0
? await Promise.all(
watermarkMedia.videoTranscodes.map(async (vt) => ({
id: vt.key ?? '',
url: vt.key ? await s3Service.presign(bucket, vt.key, 'GET') : '',
key: vt.key ?? '',
width: vt.width ?? 0,
height: vt.height ?? 0,
size: 0,
})),
)
: []
updatedMedia.imageTranscodes =
watermarkMedia?.imageTranscodes && watermarkMedia.imageTranscodes.length > 0
? await Promise.all(
watermarkMedia.imageTranscodes.map(async (it) => ({
id: it.key ?? '',
url: it.key ? await s3Service.presign(bucket, it.key, 'GET') : '',
key: it.key ?? '',
width: it.width ?? 0,
height: it.height ?? 0,
size: 0,
})),
)
: []
return {
...asset,
media: updatedMedia,
}
}
const app = new Hono()
@@ -46,6 +105,10 @@ export function handlePublicShareError(c: Context, err: unknown) {
const msg = err instanceof Error ? err.message : String(err)
return c.json({ error: msg }, 403)
}
if (err instanceof ShareLinkDownloadDisabledError) {
const msg = err instanceof Error ? err.message : String(err)
return c.json({ error: msg }, 403)
}
if (err instanceof ShareLinkNotFoundError) {
const msg = err instanceof Error ? err.message : String(err)
return c.json({ error: msg }, 404)
@@ -70,6 +133,7 @@ const route = app
name: shareLink.name,
expireAt: shareLink.expireAt,
isDisabled: shareLink.isDisabled,
allowDownload: shareLink.allowDownload,
isExpired: shareLink.isExpired,
hasPassword: shareLink.hasPassword,
rootFolderId: shareLink.rootFolderId,
@@ -129,6 +193,24 @@ const route = app
order,
})
if (shareLink.watermarkConfigId && res.data.length > 0) {
// Resolve symlink targets once and reuse for the media lookup, so each
// item costs a single query instead of two.
const targetIds = await Promise.all(
res.data.map((item) => assetService.resolveTargetAssetId(item.id)),
)
const wfMap = await watermarkService.getCompletedWatermarkMediaMap(
targetIds,
shareLink.watermarkConfigId,
)
res.data = await Promise.all(
res.data.map(async (item, index) =>
applyWatermarkToAssetMedia(item, wfMap.get(targetIds[index]) ?? null),
),
)
}
return c.json(res)
} catch (err) {
return handlePublicShareError(c, err)
@@ -140,9 +222,24 @@ const route = app
const password = c.req.header('x-share-password')
try {
await shareService.verifyPublicAccess(fileId, password)
const shareLink = await shareService.verifyPublicAccess(fileId, password)
let asset = await assetService.getAsset({ assetId: fileId })
// Only video/image assets are subject to watermark protection; skip the
// watermark lookup entirely for other media types (pdf, audio, ...).
if (
shareLink.watermarkConfigId &&
(asset.proxyType === 'video' || asset.proxyType === 'image')
) {
const targetAssetId = await assetService.resolveTargetAssetId(fileId)
const wfMap = await watermarkService.getCompletedWatermarkMediaMap(
[targetAssetId],
shareLink.watermarkConfigId,
)
asset = await applyWatermarkToAssetMedia(asset, wfMap.get(targetAssetId) ?? null)
}
const asset = await assetService.getAsset({ assetId: fileId })
return c.json(asset)
} catch (err) {
return handlePublicShareError(c, err)
@@ -157,7 +254,11 @@ const route = app
const { key } = c.req.valid('json')
try {
await shareService.verifyPublicAccess(fileId, password)
const shareLink = await shareService.verifyPublicAccess(fileId, password)
if (!shareLink.allowDownload) {
throw new ShareLinkDownloadDisabledError('Download is disabled for this share link')
}
if (!key.startsWith('files/')) {
return c.json({ error: 'Invalid key' }, 400)
+21 -4
View File
@@ -39,7 +39,7 @@ describe('S3 API', () => {
}
})
it('GET /files/* sets Content-Disposition: attachment only when download=1 query param is present', async () => {
it('GET /files/* sets Content-Disposition with filename when download=1 & filename query params are present', async () => {
// We need to capture the onFound callback from serveStatic options
// eslint-disable-next-line @typescript-eslint/no-explicit-any
let onFoundCallback: ((path: string, c: any) => void) | undefined
@@ -54,19 +54,36 @@ describe('S3 API', () => {
const { default: route } = await import('./s3')
const app = new Hono().route('/files', route)
await app.request('/files/b1/test.webp?download=1')
await app.request('/files/b1/test.webp?download=1&filename=foo.png')
expect(onFoundCallback).toBeDefined()
// Test with download=1
// Test with download=1 and filename
const mockContextWithDownload = {
req: { query: (key: string) => (key === 'download' ? '1' : undefined) },
req: {
query: (key: string) =>
key === 'download' ? '1' : key === 'filename' ? 'foo.png' : undefined,
},
header: vi.fn(),
}
if (onFoundCallback) {
onFoundCallback('/files/b1/test.webp', mockContextWithDownload)
expect(mockContextWithDownload.header).toHaveBeenCalledWith(
'Content-Disposition',
'attachment; filename="foo.png"; filename*=UTF-8\'\'foo.png',
)
}
// Test with download=1 but no filename
const mockContextDownloadNoFilename = {
req: { query: (key: string) => (key === 'download' ? '1' : undefined) },
header: vi.fn(),
}
if (onFoundCallback) {
onFoundCallback('/files/b1/test.webp', mockContextDownloadNoFilename)
expect(mockContextDownloadNoFilename.header).toHaveBeenCalledWith(
'Content-Disposition',
'attachment',
)
+2 -2
View File
@@ -1,5 +1,5 @@
import { Hono } from 'hono'
import { s3Service } from '@shumai/core/src/s3/s3'
import { buildContentDisposition, s3Service } from '@shumai/core/src/s3/s3'
import { serveStatic } from 'hono/bun'
const route = new Hono()
@@ -10,7 +10,7 @@ const route = new Hono()
rewriteRequestPath: (path) => path.replace(/^\/files\//, ''),
onFound: (_path, c) => {
if (c.req.query('download') === '1') {
c.header('Content-Disposition', 'attachment')
c.header('Content-Disposition', buildContentDisposition(c.req.query('filename')))
}
},
}),
+495
View File
@@ -9,6 +9,8 @@ import { authzService, Permission, ResourceType } from '@shumai/core/src/authz/a
import { ShareLinkPasswordInvalidError, ShareLinkExpiredError } from '@shumai/core/src/share/errors'
import { auditLogService } from '@shumai/core/src/auditLog/auditLog'
import { watermarkService } from '@shumai/core/src/watermark/watermark'
import { s3Service } from '@shumai/core/src/s3/s3'
vi.mock('./middleware/auth', () => ({
// eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -47,6 +49,35 @@ vi.mock('@shumai/core/src/project/project', () => ({
},
}))
function watermarkMediaInfo(overrides: Partial<PrismaJson.MediaInfo> = {}): PrismaJson.MediaInfo {
return {
duration: 1,
filesize: 100,
frames: 30,
proxyType: 'video',
imageTranscodes: [],
videoTranscodes: [],
finishedAt: new Date().toISOString(),
metadata: {
originalHeight: 360,
originalWidth: 640,
hasAudio: false,
duration: 1,
bitRate: 0,
frameRate: 30,
totalFrames: 30,
startTimecode: '00:00:00:00',
format: {},
},
original: {
key: 'files/orig.mp4',
filesizeInBytes: 100,
codec: '',
},
...overrides,
}
}
describe('Share API', () => {
const app = new Hono()
.route('/', publicShareRoute)
@@ -65,6 +96,7 @@ describe('Share API', () => {
id: 'share1',
name: 'Public Share',
isDisabled: false,
allowDownload: false,
isExpired: false,
hasPassword: true,
rootFolderId: 'folder1',
@@ -88,6 +120,7 @@ describe('Share API', () => {
const body = await res.json()
expect(body.name).toBe('Public Share')
expect(body.hasPassword).toBe(true)
expect(body.allowDownload).toBe(false)
expect(shareService.verifyPublicAccess).toHaveBeenCalledWith('folder1', 'pass')
})
@@ -96,6 +129,7 @@ describe('Share API', () => {
id: 'share1',
name: 'Public Share',
isDisabled: false,
allowDownload: false,
isExpired: false,
hasPassword: true,
rootFolderId: 'folder1',
@@ -122,6 +156,7 @@ describe('Share API', () => {
id: 'share1',
name: 'Public Share',
isDisabled: false,
allowDownload: false,
isExpired: false,
hasPassword: true,
rootFolderId: 'folder1',
@@ -149,6 +184,7 @@ describe('Share API', () => {
id: 'share1',
name: 'My Share',
isDisabled: false,
allowDownload: false,
rootFolderId: 'folder1',
projectId: 'project1',
password: null,
@@ -180,6 +216,291 @@ describe('Share API', () => {
}),
)
})
test('applies per-file watermark proxies when watermark enabled', async () => {
vi.spyOn(shareService, 'verifyPublicAccess').mockResolvedValue({
id: 'share1',
name: 'My Share',
isDisabled: false,
allowDownload: false,
rootFolderId: 'folder1',
projectId: 'project1',
password: null,
expireAt: null,
watermarkConfigId: 'cfg1',
// eslint-disable-next-line @typescript-eslint/no-explicit-any
} as any)
vi.spyOn(assetService, 'listChildren').mockResolvedValue({
data: [
{
id: 'video-ready',
name: 'a.mp4',
sizeByte: 1,
fileCount: 0,
type: 'file',
status: 'processed',
proxyType: 'video',
media: {
proxyType: 'video',
videoTranscodes: [
{
id: 'orig',
url: 'u',
key: 'files/orig.mp4',
width: 640,
height: 360,
size: 1,
},
],
imageTranscodes: [],
original: { key: 'files/orig.mp4' },
},
},
{
id: 'video-pending',
name: 'b.mp4',
sizeByte: 1,
fileCount: 0,
type: 'file',
status: 'processed',
proxyType: 'video',
media: {
proxyType: 'video',
videoTranscodes: [
{
id: 'orig',
url: 'u',
key: 'files/orig.mp4',
width: 640,
height: 360,
size: 1,
},
],
imageTranscodes: [],
original: { key: 'files/orig.mp4' },
},
},
{
id: 'doc',
name: 'c.pdf',
sizeByte: 1,
fileCount: 0,
type: 'file',
status: 'processed',
proxyType: 'pdf',
media: {
proxyType: 'pdf',
pdfTranscode: { url: 'u', key: 'files/doc.pdf' },
videoTranscodes: [],
imageTranscodes: [],
original: { key: 'files/doc.pdf' },
},
},
// eslint-disable-next-line @typescript-eslint/no-explicit-any
] as any,
pageInfo: { total: 3, cursor: undefined },
})
vi.spyOn(assetService, 'resolveTargetAssetId').mockImplementation(async (id) => id)
vi.spyOn(s3Service, 'presign').mockResolvedValue('http://s3/presigned')
vi.spyOn(watermarkService, 'getCompletedWatermarkMediaMap').mockResolvedValue(
new Map([
[
'video-ready',
watermarkMediaInfo({
videoTranscodes: [{ key: 'files/wm-a.mp4', width: 640, height: 360 }],
}),
],
]),
)
const res = await app.request('/shares/share1/folders/folder1/children?assetType=file', {
method: 'GET',
headers: { 'x-share-password': 'pass' },
})
expect(res.status).toBe(200)
const body = await res.json()
// Ready item → watermarked proxy
expect(body.data[0].media.videoTranscodes).toEqual([
{
id: 'files/wm-a.mp4',
url: 'http://s3/presigned',
key: 'files/wm-a.mp4',
width: 640,
height: 360,
size: 0,
},
])
// Pending item → original transcodes emptied
expect(body.data[1].media.videoTranscodes).toEqual([])
expect(body.data[1].media.imageTranscodes).toEqual([])
// Non-media item → untouched
expect(body.data[2].media.pdfTranscode).toEqual({ url: 'u', key: 'files/doc.pdf' })
})
})
describe('GET /shares/:shareId/files/:fileId', () => {
const shareLinkWithWatermark = {
id: 'share1',
name: 'My Share',
isDisabled: false,
allowDownload: false,
rootFolderId: 'folder1',
projectId: 'project1',
password: null,
expireAt: null,
watermarkConfigId: 'cfg1',
// eslint-disable-next-line @typescript-eslint/no-explicit-any
} as any
const videoAsset = {
id: 'file1',
name: 'video.mp4',
sizeByte: 1024,
fileCount: 0,
type: 'file',
status: 'processed',
proxyType: 'video',
media: {
proxyType: 'video',
videoTranscodes: [
{
id: 'orig-360p',
url: 'http://s3/original-360p',
key: 'files/original-360p.mp4',
width: 640,
height: 360,
size: 100,
},
],
imageTranscodes: [],
original: { key: 'files/original.mp4' },
},
// eslint-disable-next-line @typescript-eslint/no-explicit-any
} as any
beforeEach(() => {
vi.spyOn(assetService, 'getAsset').mockResolvedValue(videoAsset)
vi.spyOn(assetService, 'resolveTargetAssetId').mockResolvedValue('file1')
vi.spyOn(s3Service, 'presign').mockResolvedValue('http://s3/presigned')
})
test('serves watermarked transcodes when watermark enabled and completed', async () => {
vi.spyOn(shareService, 'verifyPublicAccess').mockResolvedValue(shareLinkWithWatermark)
vi.spyOn(watermarkService, 'getCompletedWatermarkMediaMap').mockResolvedValue(
new Map([
[
'file1',
watermarkMediaInfo({
videoTranscodes: [{ key: 'files/watermarked-360p.mp4', width: 640, height: 360 }],
}),
],
]),
)
const res = await app.request('/shares/share1/files/file1', {
method: 'GET',
headers: { 'x-share-password': 'pass' },
})
expect(res.status).toBe(200)
const body = await res.json()
expect(body.media.videoTranscodes).toEqual([
{
id: 'files/watermarked-360p.mp4',
url: 'http://s3/presigned',
key: 'files/watermarked-360p.mp4',
width: 640,
height: 360,
size: 0,
},
])
expect(body.media.imageTranscodes).toEqual([])
})
test('serves empty transcode arrays while watermark transcoding is in flight', async () => {
vi.spyOn(shareService, 'verifyPublicAccess').mockResolvedValue(shareLinkWithWatermark)
vi.spyOn(watermarkService, 'getCompletedWatermarkMediaMap').mockResolvedValue(new Map())
const res = await app.request('/shares/share1/files/file1', {
method: 'GET',
headers: { 'x-share-password': 'pass' },
})
expect(res.status).toBe(200)
const body = await res.json()
expect(body.media.videoTranscodes).toEqual([])
expect(body.media.imageTranscodes).toEqual([])
})
test('leaves non-video/image media untouched when watermark enabled', async () => {
vi.spyOn(shareService, 'verifyPublicAccess').mockResolvedValue(shareLinkWithWatermark)
vi.spyOn(assetService, 'getAsset').mockResolvedValue({
id: 'file1',
name: 'doc.pdf',
sizeByte: 1024,
fileCount: 0,
type: 'file',
status: 'processed',
proxyType: 'pdf',
media: {
proxyType: 'pdf',
pdfTranscode: { url: 'http://s3/doc', key: 'files/doc.pdf' },
videoTranscodes: [],
imageTranscodes: [],
original: { key: 'files/doc.pdf' },
},
// eslint-disable-next-line @typescript-eslint/no-explicit-any
} as any)
const resolveSpy = vi.spyOn(assetService, 'resolveTargetAssetId')
const wfSpy = vi.spyOn(watermarkService, 'getCompletedWatermarkMediaMap')
const res = await app.request('/shares/share1/files/file1', {
method: 'GET',
headers: { 'x-share-password': 'pass' },
})
expect(res.status).toBe(200)
const body = await res.json()
expect(body.media.pdfTranscode).toEqual({ url: 'http://s3/doc', key: 'files/doc.pdf' })
expect(resolveSpy).not.toHaveBeenCalled()
expect(wfSpy).not.toHaveBeenCalled()
})
test('serves original media unchanged when watermark disabled', async () => {
vi.spyOn(shareService, 'verifyPublicAccess').mockResolvedValue({
id: 'share1',
name: 'My Share',
isDisabled: false,
allowDownload: false,
rootFolderId: 'folder1',
projectId: 'project1',
password: null,
expireAt: null,
watermarkConfigId: null,
// eslint-disable-next-line @typescript-eslint/no-explicit-any
} as any)
const wfSpy = vi.spyOn(watermarkService, 'getCompletedWatermarkMediaMap')
const res = await app.request('/shares/share1/files/file1', {
method: 'GET',
headers: { 'x-share-password': 'pass' },
})
expect(res.status).toBe(200)
const body = await res.json()
expect(body.media.videoTranscodes).toEqual([
{
id: 'orig-360p',
url: 'http://s3/original-360p',
key: 'files/original-360p.mp4',
width: 640,
height: 360,
size: 100,
},
])
expect(wfSpy).not.toHaveBeenCalled()
})
})
// Protected Routes
@@ -189,6 +510,7 @@ describe('Share API', () => {
id: 'share1',
name: 'test-share',
isDisabled: false,
allowDownload: false,
rootFolderId: 'root1',
projectId: 'project1',
isExpired: false,
@@ -226,6 +548,34 @@ describe('Share API', () => {
itemId: 'share1',
})
})
test('Passes allowDownload to service', async () => {
vi.spyOn(shareService, 'createShareLink').mockResolvedValue({
id: 'share1',
name: 'test-share',
isDisabled: false,
allowDownload: false,
rootFolderId: 'root1',
projectId: 'project1',
isExpired: false,
hasPassword: false,
createdAt: new Date().toISOString(),
updatedAt: new Date().toISOString(),
})
const res = await app.request('/projects/project1/shares', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ name: 'My Share', allowDownload: false }),
})
expect(res.status).toBe(200)
expect(shareService.createShareLink).toHaveBeenCalledWith(
'project1',
{ name: 'My Share', allowDownload: false },
'user1',
)
})
})
describe('GET /projects/:projectId/shares', () => {
@@ -261,6 +611,7 @@ describe('Share API', () => {
id: 'share1',
name: 'test-share',
isDisabled: false,
allowDownload: false,
rootFolderId: 'root1',
projectId: 'project1',
isExpired: false,
@@ -291,6 +642,7 @@ describe('Share API', () => {
id: 'share1',
name: 'test-share',
isDisabled: false,
allowDownload: false,
rootFolderId: 'root1',
projectId: 'project1',
isExpired: false,
@@ -326,4 +678,147 @@ describe('Share API', () => {
expect(shareService.addAssetToShare).toHaveBeenCalledWith('share1', { assetIds: ['asset1'] })
})
})
describe('Watermark API', () => {
test('PUT /shares/:shareId/watermark success', async () => {
const { watermarkService } = await import('@shumai/core/src/watermark/watermark')
vi.spyOn(watermarkService, 'updateShareLinkWatermark').mockResolvedValue({
id: 'share1',
name: 'test-share',
isDisabled: false,
allowDownload: false,
rootFolderId: 'root1',
projectId: 'project1',
isExpired: false,
hasPassword: false,
watermarkStatus: 'processing',
watermarkConfigId: 'cfg1',
createdAt: new Date().toISOString(),
updatedAt: new Date().toISOString(),
})
const res = await app.request('/shares/share1/watermark', {
method: 'PUT',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
enabled: true,
config: {
blocks: [
{
id: 'b1',
type: 'text',
x: 0.5,
y: 0.5,
opacity: 0.5,
rotation: 0,
text: 'TEST',
size: 0.1,
color: '#FFF',
},
],
},
}),
})
expect(res.status).toBe(200)
const body = await res.json()
expect(body.watermarkStatus).toBe('processing')
})
test('PUT /shares/:shareId/watermark conflict 409', async () => {
const { watermarkService } = await import('@shumai/core/src/watermark/watermark')
const { ShareLinkWatermarkProcessingError } = await import('@shumai/core/src/share/errors')
vi.spyOn(watermarkService, 'updateShareLinkWatermark').mockRejectedValue(
new ShareLinkWatermarkProcessingError(),
)
const res = await app.request('/shares/share1/watermark', {
method: 'PUT',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ enabled: false }),
})
expect(res.status).toBe(409)
const body = await res.json()
expect(body.error).toBe('Watermark transcoding is currently in progress')
})
test('PUT /shares/:shareId/watermark without config when enabled returns 400', async () => {
const res = await app.request('/shares/share1/watermark', {
method: 'PUT',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ enabled: true }),
})
expect(res.status).toBe(400)
})
test('GET /shares/:shareId/watermark success', async () => {
const { watermarkService } = await import('@shumai/core/src/watermark/watermark')
vi.spyOn(watermarkService, 'getShareLinkWatermark').mockResolvedValue({
watermarkStatus: 'ready',
watermarkConfig: {
id: 'cfg1',
config: { blocks: [] },
hash: 'h1',
createdAt: new Date().toISOString(),
updatedAt: new Date().toISOString(),
},
})
const res = await app.request('/shares/share1/watermark', {
method: 'GET',
})
expect(res.status).toBe(200)
const body = await res.json()
expect(body.watermarkStatus).toBe('ready')
expect(body.watermarkConfig.hash).toBe('h1')
})
})
describe('POST /shares/:shareId/files/:fileId/download-url', () => {
test('Success for symlink asset in share', async () => {
vi.spyOn(shareService, 'verifyPublicAccess').mockResolvedValue({
allowDownload: true,
// eslint-disable-next-line @typescript-eslint/no-explicit-any
} as any)
vi.spyOn(assetService, 'getDownloadUrl').mockResolvedValue('https://s3.example.com/download')
const res = await app.request('/shares/share1/files/symlink1/download-url', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ key: 'files/target1/fly.png' }),
})
expect(res.status).toBe(200)
const body = await res.json()
expect(body.url).toBe('https://s3.example.com/download')
expect(shareService.verifyPublicAccess).toHaveBeenCalledWith('symlink1', undefined)
expect(assetService.getDownloadUrl).toHaveBeenCalledWith('symlink1', 'files/target1/fly.png')
})
test('Rejects when allowDownload is disabled', async () => {
vi.spyOn(shareService, 'verifyPublicAccess').mockResolvedValue({
id: 'share1',
name: 'No Download',
allowDownload: false,
// eslint-disable-next-line @typescript-eslint/no-explicit-any
} as any)
const getDownloadUrlSpy = vi
.spyOn(assetService, 'getDownloadUrl')
.mockResolvedValue('https://s3.example.com/download')
const res = await app.request('/shares/share1/files/symlink1/download-url', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ key: 'files/target1/fly.png' }),
})
expect(res.status).toBe(403)
const body = await res.json()
expect(body.error).toBe('Download is disabled for this share link')
expect(getDownloadUrlSpy).not.toHaveBeenCalled()
})
})
})
+53
View File
@@ -8,10 +8,16 @@ import {
updateShareLinkRequestSchema,
listShareLinksRequestSchema,
addAssetToShareRequestSchema,
updateShareLinkWatermarkRequestSchema,
AuditAction,
} from '@shumai/dtos'
import type { Prisma } from '@shumai/db'
import { auditLogService } from '@shumai/core/src/auditLog/auditLog'
import { watermarkService } from '@shumai/core/src/watermark/watermark'
import {
ShareLinkNotFoundError,
ShareLinkWatermarkProcessingError,
} from '@shumai/core/src/share/errors'
type User = Prisma.UserGetPayload<Record<string, never>>
@@ -183,5 +189,52 @@ const route = new Hono<{ Variables: { user: User } }>()
await shareService.removeAssetFromShare(shareId, assetId)
return c.body(null, 204)
})
.put(
'/shares/:shareId/watermark',
zValidator('json', updateShareLinkWatermarkRequestSchema),
async (c) => {
const shareId = c.req.param('shareId')
const user = c.get('user')
const req = c.req.valid('json')
await authzService.hasPermission({
user,
permission: Permission.Edit,
type: ResourceType.Share,
id: shareId,
})
try {
const updated = await watermarkService.updateShareLinkWatermark(
shareId,
req.enabled,
req.config,
)
return c.json(updated)
} catch (err) {
if (err instanceof ShareLinkWatermarkProcessingError) {
return c.json({ error: err.message }, 409)
}
if (err instanceof ShareLinkNotFoundError) {
return c.json({ error: err.message }, 404)
}
throw err
}
},
)
.get('/shares/:shareId/watermark', async (c) => {
const shareId = c.req.param('shareId')
const user = c.get('user')
await authzService.hasPermission({
user,
permission: Permission.Read,
type: ResourceType.Share,
id: shareId,
})
const res = await watermarkService.getShareLinkWatermark(shareId)
return c.json(res)
})
export default route
+146
View File
@@ -0,0 +1,146 @@
import { describe, expect, test, vi, beforeEach } from 'vitest'
import { Hono } from 'hono'
import watermarkTemplateRoute from './watermark-template'
import { authMiddleware } from './middleware/auth'
import { authzService } from '@shumai/core/src/authz/authz'
import { watermarkService } from '@shumai/core/src/watermark/watermark'
import { teamService } from '@shumai/core/src/team/team'
vi.mock('./middleware/auth', () => ({
// eslint-disable-next-line @typescript-eslint/no-explicit-any
authMiddleware: async (c: any, next: any) => {
// eslint-disable-next-line @typescript-eslint/no-explicit-any
c.set('user', { id: 'user1', name: 'Test User' } as any)
await next()
},
}))
vi.mock('@shumai/core/src/authz/authz', () => ({
authzService: {
hasPermission: vi.fn().mockResolvedValue(undefined),
},
Permission: {
Read: 'Read',
Edit: 'Edit',
Admin: 'Admin',
},
ResourceType: {
Team: 'team',
},
}))
describe('Watermark Template API', () => {
const app = new Hono().use('*', authMiddleware).route('/', watermarkTemplateRoute)
beforeEach(() => {
vi.restoreAllMocks()
vi.mocked(authzService.hasPermission).mockResolvedValue(undefined)
})
test('GET /watermark-templates', async () => {
vi.spyOn(watermarkService, 'listTemplates').mockResolvedValue([
{
id: 'tpl1',
name: 'Preset 1',
config: { blocks: [] },
teamId: 't1',
createdAt: new Date().toISOString(),
updatedAt: new Date().toISOString(),
},
])
const res = await app.request('/watermark-templates?teamId=t1', {
method: 'GET',
})
expect(res.status).toBe(200)
const body = await res.json()
expect(body).toHaveLength(1)
expect(body[0].name).toBe('Preset 1')
})
test("GET /watermark-templates without teamId scopes to the caller's teams", async () => {
vi.spyOn(teamService, 'getUserTeams').mockResolvedValue({
// eslint-disable-next-line @typescript-eslint/no-explicit-any
data: [{ id: 't1', name: 'My Team' }] as any,
// eslint-disable-next-line @typescript-eslint/no-explicit-any
pageInfo: {} as any,
})
vi.spyOn(watermarkService, 'listTemplates').mockResolvedValue([])
const res = await app.request('/watermark-templates', {
method: 'GET',
})
expect(res.status).toBe(200)
expect(watermarkService.listTemplates).toHaveBeenCalledWith(['t1'])
})
test('POST /watermark-templates', async () => {
vi.spyOn(teamService, 'getUserTeams').mockResolvedValue({
// eslint-disable-next-line @typescript-eslint/no-explicit-any
data: [{ id: 't1', name: 'My Team' }] as any,
// eslint-disable-next-line @typescript-eslint/no-explicit-any
pageInfo: {} as any,
})
vi.spyOn(watermarkService, 'createTemplate').mockResolvedValue({
id: 'tpl1',
name: 'New Preset',
config: { blocks: [] },
teamId: 't1',
createdAt: new Date().toISOString(),
updatedAt: new Date().toISOString(),
})
const res = await app.request('/watermark-templates', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
name: 'New Preset',
config: { blocks: [] },
}),
})
expect(res.status).toBe(201)
const body = await res.json()
expect(body.name).toBe('New Preset')
})
test('DELETE /watermark-templates/:templateId', async () => {
vi.spyOn(watermarkService, 'getTemplate').mockResolvedValue({
id: 'tpl1',
name: 'New Preset',
config: { blocks: [] },
teamId: 't1',
createdAt: new Date().toISOString(),
updatedAt: new Date().toISOString(),
})
vi.spyOn(watermarkService, 'deleteTemplate').mockResolvedValue(undefined)
const res = await app.request('/watermark-templates/tpl1', {
method: 'DELETE',
})
expect(res.status).toBe(204)
expect(watermarkService.deleteTemplate).toHaveBeenCalledWith('tpl1')
})
test('DELETE /watermark-templates/:templateId on a teamless template returns 403', async () => {
vi.spyOn(watermarkService, 'getTemplate').mockResolvedValue({
id: 'tpl-global',
name: 'Platform Preset',
config: { blocks: [] },
teamId: null,
createdAt: new Date().toISOString(),
updatedAt: new Date().toISOString(),
})
vi.spyOn(watermarkService, 'deleteTemplate').mockResolvedValue(undefined)
const res = await app.request('/watermark-templates/tpl-global', {
method: 'DELETE',
})
expect(res.status).toBe(403)
expect(watermarkService.deleteTemplate).not.toHaveBeenCalled()
})
})
+145
View File
@@ -0,0 +1,145 @@
import { Hono } from 'hono'
import { zValidator } from '@hono/zod-validator'
import { authzService, Permission, ResourceType } from '@shumai/core/src/authz/authz'
import { teamService } from '@shumai/core/src/team/team'
import { watermarkService } from '@shumai/core/src/watermark/watermark'
import {
createWatermarkTemplateRequestSchema,
updateWatermarkTemplateRequestSchema,
} from '@shumai/dtos'
import { z } from 'zod'
import type { Prisma } from '@shumai/db'
type User = Prisma.UserGetPayload<Record<string, never>>
const listTemplatesQuerySchema = z.object({
teamId: z.string().optional(),
})
const route = new Hono<{ Variables: { user: User } }>()
.get('/watermark-templates', zValidator('query', listTemplatesQuerySchema), async (c) => {
const user = c.get('user')
const { teamId } = c.req.valid('query')
let teamIds: string[]
if (teamId) {
await authzService.hasPermission({
user,
permission: Permission.Read,
type: ResourceType.Team,
id: teamId,
})
teamIds = [teamId]
} else {
// No teamId: scope to the caller's own teams so templates are never
// leaked across tenants.
const userTeams = await teamService.getUserTeams({
userId: user.id,
pagination: { first: 20 },
})
teamIds = userTeams.data.map((t) => t.id)
}
const templates = await watermarkService.listTemplates(teamIds)
return c.json(templates)
})
.get('/watermark-templates/:templateId', async (c) => {
const templateId = c.req.param('templateId')
const template = await watermarkService.getTemplate(templateId)
if (template.teamId) {
const user = c.get('user')
await authzService.hasPermission({
user,
permission: Permission.Read,
type: ResourceType.Team,
id: template.teamId,
})
}
// Teamless templates are shared platform defaults: readable by any
// authenticated user, but not writable (enforced on PUT/DELETE).
return c.json(template)
})
.post(
'/watermark-templates',
zValidator('json', createWatermarkTemplateRequestSchema),
async (c) => {
const user = c.get('user')
const req = c.req.valid('json')
let teamId: string | null
if (req.teamId) {
await authzService.hasPermission({
user,
permission: Permission.Edit,
type: ResourceType.Team,
id: req.teamId,
})
teamId = req.teamId
} else {
const userTeams = await teamService.getUserTeams({
userId: user.id,
pagination: { first: 20 },
})
teamId = userTeams.data[0]?.id || null
if (!teamId) {
return c.json({ error: 'A team is required to create a watermark template' }, 400)
}
await authzService.hasPermission({
user,
permission: Permission.Edit,
type: ResourceType.Team,
id: teamId,
})
}
const template = await watermarkService.createTemplate(teamId, req.name, req.config)
return c.json(template, 201)
},
)
.put(
'/watermark-templates/:templateId',
zValidator('json', updateWatermarkTemplateRequestSchema),
async (c) => {
const templateId = c.req.param('templateId')
const user = c.get('user')
const req = c.req.valid('json')
const existing = await watermarkService.getTemplate(templateId)
if (existing.teamId) {
await authzService.hasPermission({
user,
permission: Permission.Edit,
type: ResourceType.Team,
id: existing.teamId,
})
} else {
return c.json({ error: 'Platform templates are read-only' }, 403)
}
const updated = await watermarkService.updateTemplate(templateId, req.name, req.config)
return c.json(updated)
},
)
.delete('/watermark-templates/:templateId', async (c) => {
const templateId = c.req.param('templateId')
const user = c.get('user')
const existing = await watermarkService.getTemplate(templateId)
if (existing.teamId) {
await authzService.hasPermission({
user,
permission: Permission.Edit,
type: ResourceType.Team,
id: existing.teamId,
})
} else {
return c.json({ error: 'Platform templates are read-only' }, 403)
}
await watermarkService.deleteTemplate(templateId)
return c.body(null, 204)
})
export default route
+4 -1
View File
@@ -1,6 +1,6 @@
{
"name": "@shumai/core",
"version": "0.3.3",
"version": "0.3.6",
"private": true,
"type": "module",
"main": "./src/index.ts",
@@ -8,6 +8,7 @@
"dependencies": {
"@earendil-works/pi-agent-core": "0.82.1",
"@earendil-works/pi-ai": "0.82.1",
"@modelcontextprotocol/client": "2.0.0",
"@shumai/db": "workspace:*",
"@shumai/dtos": "workspace:*",
"@sinclair/typebox": "0.34.49",
@@ -24,11 +25,13 @@
"pino": "10.3.1",
"sharp": "0.34.5",
"tweetnacl": "1.0.3",
"typebox": "1.1.38",
"ulid": "3.0.2",
"yaml": "2.9.0",
"zod": "4.4.3"
},
"devDependencies": {
"@modelcontextprotocol/server": "2.0.0",
"@types/adm-zip": "0.5.8",
"@types/extract-zip": "2.0.3",
"@types/pdfkit": "0.17.6"
+30 -2
View File
@@ -121,6 +121,7 @@ export class AgentService {
systemPrompt,
soul,
skills,
mcpServerIds,
deniedTools,
} = params
@@ -189,6 +190,12 @@ export class AgentService {
skillId,
})) || [],
},
mcpServers: {
create:
mcpServerIds?.map((mcpServerId) => ({
mcpServerId,
})) || [],
},
},
})
@@ -202,7 +209,11 @@ export class AgentService {
return tx.agent.findUnique({
where: { id: agent.id },
include: { user: true, skills: { include: { skill: true } } },
include: {
user: true,
skills: { include: { skill: true } },
mcpServers: { include: { mcpServer: true } },
},
})
})
}
@@ -220,6 +231,7 @@ export class AgentService {
systemPrompt,
soul,
skills,
mcpServerIds,
deniedTools,
} = params
@@ -278,6 +290,11 @@ export class AgentService {
where: { agentId },
})
// Update MCP server assignments: easier to delete all and recreate
await tx.agentMcpServer.deleteMany({
where: { agentId },
})
return tx.agent.update({
where: { id: agentId },
data: {
@@ -294,8 +311,18 @@ export class AgentService {
skillId,
})) || [],
},
mcpServers: {
create:
mcpServerIds?.map((mcpServerId) => ({
mcpServerId,
})) || [],
},
},
include: {
user: true,
skills: { include: { skill: true } },
mcpServers: { include: { mcpServer: true } },
},
include: { user: true, skills: { include: { skill: true } } },
})
})
}
@@ -338,6 +365,7 @@ export class AgentService {
skill: true,
},
},
mcpServers: true,
},
})
}
+76
View File
@@ -4,6 +4,7 @@ import { setupTestDbHooks } from '@shumai/db/test'
import { HTTPException } from 'hono/http-exception'
import { AssetType, AssetStatus, Prisma } from '@shumai/db'
import { s3Service } from '@shumai/core/src/s3/s3'
import { AssetService } from './asset'
vi.mock('@shumai/core/src/s3/s3', () => ({
@@ -2229,6 +2230,18 @@ describe('AssetService — natural sort by name', () => {
for (const item of result) {
expect(item.url).toBe('http://mock-s3-url')
}
// Renamed file names must be passed to presign so the download
// Content-Disposition header uses the asset name, not the storage key
for (const name of ['file1.txt', 'file2.txt', 'version2.txt']) {
expect(s3Service.presign).toHaveBeenCalledWith(
expect.any(String),
expect.any(String),
'GET',
true,
name,
)
}
})
it('resolves top-level symlinks to their targets when passed as direct starting IDs', async () => {
@@ -2539,6 +2552,40 @@ describe('AssetService — natural sort by name', () => {
)
expect(url).toBe('http://mock-s3-url')
expect(s3Service.presign).toHaveBeenCalledWith(
expect.any(String),
'files/01TESTULID000000000000000/test-720p.mp4',
'GET',
true,
'test.mp4',
)
})
it('should use the renamed asset name as the download filename', async () => {
const asset = await prisma.asset.create({
data: {
name: 'foo.png',
type: AssetType.file,
status: AssetStatus.uploaded,
storageKey: {
create: { key: 'files/01RENAMEDULID0000000000000/test.png' },
},
},
})
const url = await assetService.getDownloadUrl(
asset.id,
'files/01RENAMEDULID0000000000000/test.png',
)
expect(url).toBe('http://mock-s3-url')
expect(s3Service.presign).toHaveBeenCalledWith(
expect.any(String),
'files/01RENAMEDULID0000000000000/test.png',
'GET',
true,
'foo.png',
)
})
it('should return a presigned download URL for the original key', async () => {
@@ -2617,6 +2664,35 @@ describe('AssetService — natural sort by name', () => {
assetService.getDownloadUrl(asset.id, 'files/01TESTULID000000000000000/test.mp4'),
).rejects.toThrow('Asset not found or has no storage key')
})
it('should return a presigned download URL when given a symlink asset ID', async () => {
const realAsset = await prisma.asset.create({
data: {
name: 'fly.png',
type: AssetType.file,
status: AssetStatus.uploaded,
storageKey: {
create: { key: 'files/01KZ8VH3QHKQCSQDC5JPXCYT0R/fly.png' },
},
},
})
const symlinkAsset = await prisma.asset.create({
data: {
name: 'fly.png',
type: AssetType.symlink,
status: AssetStatus.uploaded,
targetId: realAsset.id,
},
})
const url = await assetService.getDownloadUrl(
symlinkAsset.id,
'files/01KZ8VH3QHKQCSQDC5JPXCYT0R/fly.png',
)
expect(url).toBe('http://mock-s3-url')
})
})
describe('resolveLatestVersionId', () => {
+43 -16
View File
@@ -22,6 +22,7 @@ import { HTTPException } from 'hono/http-exception'
import { logger } from '@shumai/core/src/logger'
import { PaginatedData, paginateQuery, PaginationParams } from '@shumai/core/src/pagination'
import { s3Service } from '@shumai/core/src/s3/s3'
import { watermarkService } from '@shumai/core/src/watermark/watermark'
import { generateKeyBetween } from 'jittered-fractional-indexing'
import { getAvatarUrl } from '@shumai/core/src/user/avatar'
@@ -852,13 +853,6 @@ export class AssetService {
t.url = await s3Service.presign(process.env.S3_BUCKET || 'shumai', t.key, 'GET')
}
}
if (info.media.original?.key) {
info.media.original.downloadUrl = await s3Service.presign(
process.env.S3_BUCKET || 'shumai',
info.media.original.key,
'GET',
)
}
}
return info
@@ -1104,6 +1098,7 @@ export class AssetService {
await this.expireTrashedAssets()
await this.purgePendingAssets()
await this.purgeUnreferencedStorageKeys()
await watermarkService.purgeOrphanWatermarkConfigs()
} catch (e: unknown) {
console.error('Error in asset cleanup job:', e)
}
@@ -1730,7 +1725,6 @@ export class AssetService {
}
media.original = {
key,
downloadUrl: await s3Service.presign(process.env.S3_BUCKET || 'shumai', key, 'GET'),
filesizeInBytes: Number(latestVersion.sizeByte),
codec: '',
}
@@ -1972,7 +1966,13 @@ export class AssetService {
const key = file.storageKeyId ? storageKeyMap.get(file.storageKeyId) : null
if (!key) return null
const url = await s3Service.presign(process.env.S3_BUCKET || 'shumai', key, 'GET', true)
const url = await s3Service.presign(
process.env.S3_BUCKET || 'shumai',
key,
'GET',
true,
file.name,
)
return {
id: file.id,
@@ -1991,23 +1991,50 @@ export class AssetService {
* that belong to an asset they have access to.
*/
async getDownloadUrl(assetId: string, key: string): Promise<string> {
const targetAssetId = await this.resolveLatestVersionId(assetId)
const asset = await this.prismaClient.asset.findUnique({
where: { id: assetId },
select: { storageKey: { select: { key: true } } },
where: { id: targetAssetId },
select: { id: true, name: true, parentId: true, storageKey: { select: { key: true } } },
})
if (!asset?.storageKey?.key) {
throw new Error('Asset not found or has no storage key')
}
// Verify the requested key shares the same parent directory as the asset's storage key
const storageKey = asset.storageKey.key
const assetDir = storageKey.substring(0, storageKey.lastIndexOf('/') + 1)
if (key.includes('..') || !key.startsWith(assetDir)) {
if (key.includes('..')) {
throw new Error('Key does not belong to this asset')
}
return s3Service.presign(process.env.S3_BUCKET || 'shumai', key, 'GET', true)
let storageKey = asset.storageKey.key
let assetDir = storageKey.substring(0, storageKey.lastIndexOf('/') + 1)
if (!key.startsWith(assetDir) && asset.parentId) {
// Check if requested key belongs to another version in the same version stack
const sibling = await this.prismaClient.asset.findFirst({
where: {
parentId: asset.parentId,
isDeleted: false,
storageKey: { key: { startsWith: key.substring(0, key.lastIndexOf('/') + 1) } },
},
select: { storageKey: { select: { key: true } } },
})
if (sibling?.storageKey?.key) {
storageKey = sibling.storageKey.key
assetDir = storageKey.substring(0, storageKey.lastIndexOf('/') + 1)
}
}
if (!key.startsWith(assetDir)) {
throw new Error('Key does not belong to this asset')
}
return s3Service.presign(
process.env.S3_BUCKET || 'shumai',
key,
'GET',
true,
asset.name ?? undefined,
)
}
private async toPreviewInfo(asset: Asset | AssetWithIncludes): Promise<PreviewInfo | null> {
+10
View File
@@ -20,6 +20,7 @@ export enum ResourceType {
MetadataField = 'metadataField',
Skill = 'skill',
Provider = 'provider',
McpServer = 'mcpServer',
Invite = 'invite',
Comment = 'comment',
AgentSession = 'agentSession',
@@ -187,6 +188,15 @@ export class AuthzService {
return { teamId: skill.teamId }
}
case ResourceType.McpServer: {
const server = await prisma.mcpServer.findUnique({
where: { id },
select: { teamId: true },
})
if (!server) throw new HTTPException(404, { message: 'MCP server not found' })
return { teamId: server.teamId }
}
case ResourceType.Provider: {
const provider = await prisma.provider.findUnique({
where: { id },
@@ -0,0 +1,219 @@
import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
import * as fs from 'fs'
import * as path from 'path'
import * as os from 'os'
import { GotenbergService } from './gotenberg'
describe('GotenbergService', () => {
const originalEnv = process.env
let tmpDir: string
let testFilePath: string
beforeEach(() => {
process.env = { ...originalEnv }
tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gotenberg-test-'))
testFilePath = path.join(tmpDir, 'test.docx')
fs.writeFileSync(testFilePath, 'fake docx content')
})
afterEach(() => {
process.env = originalEnv
fs.rmSync(tmpDir, { recursive: true, force: true })
vi.restoreAllMocks()
})
describe('isAvailable', () => {
it('should return false if GOTENBERG_URL is not set', async () => {
delete process.env.GOTENBERG_URL
const service = new GotenbergService()
expect(await service.isAvailable()).toBe(false)
})
it('should return false if GOTENBERG_URL is empty', async () => {
process.env.GOTENBERG_URL = ' '
const service = new GotenbergService()
expect(await service.isAvailable()).toBe(false)
})
it('should return true when health check returns 200 OK', async () => {
process.env.GOTENBERG_URL = 'http://gotenberg:3000'
const fetchSpy = vi.spyOn(globalThis, 'fetch').mockResolvedValue({
ok: true,
status: 200,
} as Response)
const service = new GotenbergService()
const available = await service.isAvailable()
expect(available).toBe(true)
expect(fetchSpy).toHaveBeenCalledWith(
'http://gotenberg:3000/health',
expect.objectContaining({
method: 'GET',
}),
)
})
it('should include Basic Auth header if username and password are provided', async () => {
process.env.GOTENBERG_URL = 'http://gotenberg:3000'
process.env.GOTENBERG_BASIC_AUTH_USERNAME = 'user'
process.env.GOTENBERG_BASIC_AUTH_PASSWORD = 'pass'
const fetchSpy = vi.spyOn(globalThis, 'fetch').mockResolvedValue({
ok: true,
status: 200,
} as Response)
const service = new GotenbergService()
await service.isAvailable()
const expectedBasic = Buffer.from('user:pass').toString('base64')
expect(fetchSpy).toHaveBeenCalledWith(
'http://gotenberg:3000/health',
expect.objectContaining({
headers: {
Authorization: `Basic ${expectedBasic}`,
},
}),
)
})
it('should return false when fetch fails', async () => {
process.env.GOTENBERG_URL = 'http://gotenberg:3000'
vi.spyOn(globalThis, 'fetch').mockRejectedValue(new Error('Network error'))
const service = new GotenbergService()
expect(await service.isAvailable()).toBe(false)
})
})
describe('convertDocumentToPdf', () => {
it('should throw error if GOTENBERG_URL is not set', async () => {
delete process.env.GOTENBERG_URL
const service = new GotenbergService()
await expect(service.convertDocumentToPdf(testFilePath, 'test.docx')).rejects.toThrow(
'Gotenberg URL is not configured',
)
})
it('should call libreoffice convert endpoint and return buffer', async () => {
process.env.GOTENBERG_URL = 'http://gotenberg:3000/'
const mockPdfBuffer = Buffer.from('%PDF-1.7 mock output')
const fetchSpy = vi.spyOn(globalThis, 'fetch').mockResolvedValue({
ok: true,
status: 200,
arrayBuffer: async () => mockPdfBuffer.buffer,
} as unknown as Response)
const service = new GotenbergService()
const result = await service.convertDocumentToPdf(testFilePath, 'test.docx', {
landscape: true,
})
expect(result).toBeDefined()
expect(result.toString()).toContain('%PDF-1.7')
expect(fetchSpy).toHaveBeenCalledWith(
'http://gotenberg:3000/forms/libreoffice/convert',
expect.objectContaining({
method: 'POST',
body: expect.any(FormData),
}),
)
})
it('should throw error if gotenberg returns non-200', async () => {
process.env.GOTENBERG_URL = 'http://gotenberg:3000'
vi.spyOn(globalThis, 'fetch').mockResolvedValue({
ok: false,
status: 500,
statusText: 'Internal Server Error',
text: async () => 'Conversion failed',
} as unknown as Response)
const service = new GotenbergService()
await expect(service.convertDocumentToPdf(testFilePath, 'test.docx')).rejects.toThrow(
'Gotenberg conversion failed with status 500: Conversion failed',
)
})
})
describe('convertHtmlToPdf', () => {
it('should call chromium html convert endpoint and return buffer', async () => {
process.env.GOTENBERG_URL = 'http://gotenberg:3000'
const mockPdfBuffer = Buffer.from('%PDF-1.4 html output')
const fetchSpy = vi.spyOn(globalThis, 'fetch').mockResolvedValue({
ok: true,
status: 200,
arrayBuffer: async () => mockPdfBuffer.buffer,
} as unknown as Response)
const htmlPath = path.join(tmpDir, 'test.html')
fs.writeFileSync(htmlPath, '<h1>Hello</h1>')
const service = new GotenbergService()
const result = await service.convertHtmlToPdf(htmlPath, 'test.html')
expect(result).toBeDefined()
expect(fetchSpy).toHaveBeenCalledWith(
'http://gotenberg:3000/forms/chromium/convert/html',
expect.objectContaining({
method: 'POST',
}),
)
})
})
describe('convertMarkdownToPdf', () => {
it('should call chromium markdown convert endpoint with index.html wrapper and return buffer', async () => {
process.env.GOTENBERG_URL = 'http://gotenberg:3000'
const mockPdfBuffer = Buffer.from('%PDF-1.4 markdown output')
const fetchSpy = vi.spyOn(globalThis, 'fetch').mockResolvedValue({
ok: true,
status: 200,
arrayBuffer: async () => mockPdfBuffer.buffer,
} as unknown as Response)
const mdPath = path.join(tmpDir, 'test.md')
fs.writeFileSync(mdPath, '# Hello Gotenberg')
const service = new GotenbergService()
const result = await service.convertMarkdownToPdf(mdPath, 'test.md')
expect(result).toBeDefined()
expect(fetchSpy).toHaveBeenCalledWith(
'http://gotenberg:3000/forms/chromium/convert/markdown',
expect.objectContaining({
method: 'POST',
body: expect.any(FormData),
}),
)
})
it('should rename non-.md filenames like README.markdown to file.md for Gotenberg endpoint compatibility', async () => {
process.env.GOTENBERG_URL = 'http://gotenberg:3000'
const mockPdfBuffer = Buffer.from('%PDF-1.4 markdown output')
let capturedFormData: FormData | null = null
vi.spyOn(globalThis, 'fetch').mockImplementation(async (_url, options) => {
capturedFormData = options?.body as FormData
return {
ok: true,
status: 200,
arrayBuffer: async () => mockPdfBuffer.buffer,
} as unknown as Response
})
const mdPath = path.join(tmpDir, 'README.markdown')
fs.writeFileSync(mdPath, '# Hello Gotenberg')
const service = new GotenbergService()
await service.convertMarkdownToPdf(mdPath, 'README.markdown')
expect(capturedFormData).not.toBeNull()
const indexBlob = (capturedFormData as unknown as FormData).get('files') as File
const indexHtmlText = await indexBlob.text()
expect(indexHtmlText).toContain('{{ toHTML "file.md" }}')
})
})
})
+178
View File
@@ -0,0 +1,178 @@
import * as fs from 'fs'
export interface GotenbergConvertOptions {
landscape?: boolean
}
export class GotenbergService {
private getUrl(): string | undefined {
const url = process.env.GOTENBERG_URL?.trim()
return url ? url.replace(/\/+$/, '') : undefined
}
private getAuthHeader(): string | undefined {
const username = process.env.GOTENBERG_BASIC_AUTH_USERNAME
const password = process.env.GOTENBERG_BASIC_AUTH_PASSWORD
if (username && password) {
const credentials = Buffer.from(`${username}:${password}`).toString('base64')
return `Basic ${credentials}`
}
return undefined
}
async isAvailable(): Promise<boolean> {
const baseUrl = this.getUrl()
if (!baseUrl) {
return false
}
try {
const headers: Record<string, string> = {}
const authHeader = this.getAuthHeader()
if (authHeader) {
headers['Authorization'] = authHeader
}
const response = await fetch(`${baseUrl}/health`, {
method: 'GET',
headers,
signal: AbortSignal.timeout(3000),
})
return response.ok
} catch {
return false
}
}
async convertDocumentToPdf(
filePath: string,
filename: string,
options: GotenbergConvertOptions = {},
): Promise<Buffer> {
const baseUrl = this.getUrl()
if (!baseUrl) {
throw new Error('Gotenberg URL is not configured.')
}
const fileBytes = fs.readFileSync(filePath)
const formData = new FormData()
formData.append('files', new Blob([fileBytes]), filename)
if (options.landscape) {
formData.append('landscape', 'true')
}
const headers: Record<string, string> = {}
const authHeader = this.getAuthHeader()
if (authHeader) {
headers['Authorization'] = authHeader
}
const response = await fetch(`${baseUrl}/forms/libreoffice/convert`, {
method: 'POST',
headers,
body: formData,
signal: AbortSignal.timeout(60000),
})
if (!response.ok) {
const errorText = await response.text().catch(() => '')
throw new Error(
`Gotenberg conversion failed with status ${response.status}: ${errorText || response.statusText}`,
)
}
const arrayBuffer = await response.arrayBuffer()
return Buffer.from(arrayBuffer)
}
async convertHtmlToPdf(filePath: string, filename: string): Promise<Buffer> {
const baseUrl = this.getUrl()
if (!baseUrl) {
throw new Error('Gotenberg URL is not configured.')
}
const fileBytes = fs.readFileSync(filePath)
const formData = new FormData()
const targetFilename =
filename.toLowerCase().endsWith('.html') || filename.toLowerCase().endsWith('.htm')
? filename
: 'index.html'
formData.append('files', new Blob([fileBytes]), targetFilename)
const headers: Record<string, string> = {}
const authHeader = this.getAuthHeader()
if (authHeader) {
headers['Authorization'] = authHeader
}
const response = await fetch(`${baseUrl}/forms/chromium/convert/html`, {
method: 'POST',
headers,
body: formData,
signal: AbortSignal.timeout(60000),
})
if (!response.ok) {
const errorText = await response.text().catch(() => '')
throw new Error(
`Gotenberg HTML conversion failed with status ${response.status}: ${errorText || response.statusText}`,
)
}
const arrayBuffer = await response.arrayBuffer()
return Buffer.from(arrayBuffer)
}
async convertMarkdownToPdf(filePath: string, filename: string): Promise<Buffer> {
const baseUrl = this.getUrl()
if (!baseUrl) {
throw new Error('Gotenberg URL is not configured.')
}
const mdFilename = filename.toLowerCase().endsWith('.md') ? filename : 'file.md'
const htmlTemplate = `<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8" />
<title>PDF</title>
</head>
<body>
{{ toHTML "${mdFilename}" }}
</body>
</html>`
const fileBytes = fs.readFileSync(filePath)
const formData = new FormData()
formData.append('files', new Blob([htmlTemplate], { type: 'text/html' }), 'index.html')
formData.append('files', new Blob([fileBytes]), mdFilename)
const headers: Record<string, string> = {}
const authHeader = this.getAuthHeader()
if (authHeader) {
headers['Authorization'] = authHeader
}
const response = await fetch(`${baseUrl}/forms/chromium/convert/markdown`, {
method: 'POST',
headers,
body: formData,
signal: AbortSignal.timeout(60000),
})
if (!response.ok) {
const errorText = await response.text().catch(() => '')
throw new Error(
`Gotenberg Markdown conversion failed with status ${response.status}: ${errorText || response.statusText}`,
)
}
const arrayBuffer = await response.arrayBuffer()
return Buffer.from(arrayBuffer)
}
}
export const gotenbergService = new GotenbergService()
+3
View File
@@ -23,3 +23,6 @@ export * from './hyrumtoken'
export * from './pagination'
export * from './chat/chat'
export * from './ai-usage/ai-usage'
export * from './watermark/watermark'
export * from './gotenberg/gotenberg'
export * from './mcp/mcp-service'
+193
View File
@@ -0,0 +1,193 @@
import { describe, it, expect, beforeAll } from 'vitest'
import { prisma } from '@shumai/db'
import { setupTestDbHooks } from '@shumai/db/test'
import { McpDbStore } from './mcp-db-store'
describe('McpDbStore', () => {
setupTestDbHooks()
let store: McpDbStore
let serverId: string
beforeAll(async () => {
store = new McpDbStore()
const team = await prisma.team.create({ data: { name: 'MCP DB Store Team' } })
const server = await prisma.mcpServer.create({
data: {
name: 'github',
url: 'https://mcp.example.com/github',
teamId: team.id,
},
})
serverId = server.id
})
it('returns undefined when no credentials exist', async () => {
expect(await store.getAuthForUrl(serverId, 'https://mcp.example.com/github')).toBeUndefined()
expect(await store.hasStoredTokens(serverId)).toBe(false)
expect(await store.isTokenExpired(serverId)).toBeNull()
})
it('saves and reads tokens bound to the URL', async () => {
await store.updateTokens(
serverId,
{ accessToken: 'tok-1', refreshToken: 'ref-1' },
'https://mcp.example.com/github',
)
const entry = await store.getAuthForUrl(serverId, 'https://mcp.example.com/github')
expect(entry?.tokens?.accessToken).toBe('tok-1')
expect(entry?.tokens?.refreshToken).toBe('ref-1')
expect(await store.hasStoredTokens(serverId)).toBe(true)
})
it('invalidates credentials when the URL changes', async () => {
expect(await store.getAuthForUrl(serverId, 'https://other.example.com')).toBeUndefined()
expect(await store.hasStoredTokens(serverId)).toBe(false)
})
it('saves and clears client info', async () => {
await store.updateClientInfo(
serverId,
{ clientId: 'client-1', clientSecret: 'secret-1' },
'https://mcp.example.com/github',
)
let entry = await store.getAuthForUrl(serverId, 'https://mcp.example.com/github')
expect(entry?.clientInfo?.clientId).toBe('client-1')
await store.clearClientInfo(serverId)
entry = await store.getAuthForUrl(serverId, 'https://mcp.example.com/github')
expect(entry?.clientInfo).toBeUndefined()
})
it('saves/clears the PKCE code verifier', async () => {
await store.updateCodeVerifier(serverId, 'verifier-abc', 'https://mcp.example.com/github')
let entry = await store.getAuthForUrl(serverId, 'https://mcp.example.com/github')
expect(entry?.codeVerifier).toBe('verifier-abc')
await store.clearCodeVerifier(serverId)
entry = await store.getAuthForUrl(serverId, 'https://mcp.example.com/github')
expect(entry?.codeVerifier).toBeUndefined()
})
it('saves/clears the CSRF state', async () => {
await store.updateOauthState(serverId, 'state-xyz', 'https://mcp.example.com/github')
expect(await store.getOauthState(serverId)).toBe('state-xyz')
await store.clearOauthState(serverId)
expect(await store.getOauthState(serverId)).toBeUndefined()
})
it('detects expired tokens', async () => {
await store.updateTokens(
serverId,
{ accessToken: 'tok-expired', expiresAt: Math.floor(Date.now() / 1000) - 10 },
'https://mcp.example.com/github',
)
expect(await store.isTokenExpired(serverId)).toBe(true)
await store.updateTokens(
serverId,
{ accessToken: 'tok-valid', expiresAt: Math.floor(Date.now() / 1000) + 3600 },
'https://mcp.example.com/github',
)
expect(await store.isTokenExpired(serverId)).toBe(false)
})
it('treats tokens without an expiry as never-expiring', async () => {
await store.updateTokens(
serverId,
{ accessToken: 'tok-no-expiry' },
'https://mcp.example.com/github',
)
expect(await store.isTokenExpired(serverId)).toBe(false)
})
it('clears tokens only', async () => {
await store.updateTokens(serverId, { accessToken: 'tok-x' }, 'https://mcp.example.com/github')
await store.clearTokens(serverId)
expect(await store.hasStoredTokens(serverId)).toBe(false)
})
it('clears all credentials', async () => {
await store.updateTokens(serverId, { accessToken: 'tok-y' }, 'https://mcp.example.com/github')
await store.updateClientInfo(serverId, { clientId: 'c' }, 'https://mcp.example.com/github')
await store.clearAllCredentials(serverId)
expect(await store.getAuthForUrl(serverId, 'https://mcp.example.com/github')).toBeUndefined()
})
it('persists an in-flight pendingAuth with a TTL and expires it', async () => {
const ttl = await store.getPendingAuthTtlSeconds()
await store.savePendingAuth(serverId, {
state: 'pending-state',
authorizationUrl: 'https://auth.example.com/authorize?state=pending-state',
discovery: { scope: 'read' },
expiresAt: Math.floor(Date.now() / 1000) + ttl,
})
const pending = await store.getPendingAuth(serverId)
expect(pending?.state).toBe('pending-state')
expect(pending?.authorizationUrl).toContain('pending-state')
// Expired pendingAuth is cleared on read.
await store.savePendingAuth(serverId, {
state: 'stale',
authorizationUrl: 'https://auth.example.com/authorize',
discovery: {},
expiresAt: Math.floor(Date.now() / 1000) - 10,
})
expect(await store.getPendingAuth(serverId)).toBeUndefined()
await store.clearPendingAuth(serverId)
expect(await store.getPendingAuth(serverId)).toBeUndefined()
})
it('savePendingAuth does not clobber an in-flight discovery snapshot', async () => {
// Simulates the SDK flow: the provider's saveDiscoveryState() stores a
// snapshot inside the pendingAuth column, then startAuth() calls
// savePendingAuth(). The snapshot MUST survive so the callback leg can
// satisfy the SEP-2352 issuer check.
await store.saveDiscoverySnapshot(serverId, 'https://mcp.example.com/github', {
authorizationServerUrl: 'https://kling.ai/auth',
authorizationServerMetadata: { issuer: 'https://kling.ai/auth' },
})
await store.savePendingAuth(serverId, {
state: 'state-abc',
authorizationUrl: 'https://kling.ai/authorize',
discovery: {},
expiresAt: Math.floor(Date.now() / 1000) + 300,
})
const snapshot = await store.getDiscoverySnapshot(serverId)
expect(snapshot).toBeDefined()
expect(snapshot?.['authorizationServerUrl']).toBe('https://kling.ai/auth')
const pending = await store.getPendingAuth(serverId)
expect(pending?.state).toBe('state-abc')
})
it('persists and clears the discovery snapshot', async () => {
await store.saveDiscoverySnapshot(serverId, 'https://mcp.example.com/github', {
authorizationServerUrl: 'https://issuer.example.com',
})
const snapshot = await store.getDiscoverySnapshot(serverId)
expect(snapshot?.authorizationServerUrl).toBe('https://issuer.example.com')
await store.clearDiscoverySnapshot(serverId)
expect(await store.getDiscoverySnapshot(serverId)).toBeUndefined()
})
it('deletes the credential row when the server is deleted (cascade)', async () => {
const team = await prisma.team.create({ data: { name: 'Cascade Team' } })
const server = await prisma.mcpServer.create({
data: { name: 'cascade-srv', url: 'https://mcp.example.com/cascade', teamId: team.id },
})
await store.updateTokens(
server.id,
{ accessToken: 'tok-cascade' },
'https://mcp.example.com/cascade',
)
await prisma.mcpServer.delete({ where: { id: server.id } })
const leftover = await prisma.mcpServerCredential.findUnique({ where: { serverId: server.id } })
expect(leftover).toBeNull()
})
})
+388
View File
@@ -0,0 +1,388 @@
import { prisma, Prisma } from '@shumai/db'
export interface StoredTokens {
accessToken: string
refreshToken?: string
expiresAt?: number // Unix timestamp in seconds
scope?: string
/** SEP-2352 authorization-server issuer binding */
issuer?: string
}
export interface StoredClientInfo {
clientId: string
clientSecret?: string
clientIdIssuedAt?: number
clientSecretExpiresAt?: number
redirectUris?: string[]
issuer?: string
configPreRegistered?: boolean
}
export interface AuthEntry {
tokens?: StoredTokens
clientInfo?: StoredClientInfo
codeVerifier?: string
oauthState?: string
serverUrl?: string // Track the URL these credentials are for
}
export interface PendingAuth {
state: string
authorizationUrl: string
discovery: Record<string, unknown>
expiresAt: number // Unix timestamp in seconds
grantType?: 'authorization_code' | 'client_credentials'
redirectUri?: string
}
/** How long an in-flight authorization_code flow is kept in the DB (5 minutes). */
const PENDING_AUTH_TTL_SECONDS = 5 * 60
function rowToAuthEntry(row: {
serverUrl: string
tokens: unknown
clientInfo: unknown
codeVerifier: string | null
oauthState: string | null
pendingAuth: unknown
}): {
entry: AuthEntry
pendingAuth?: PendingAuth
} {
const entry: AuthEntry = {
serverUrl: row.serverUrl,
...(row.tokens ? { tokens: row.tokens as StoredTokens } : {}),
...(row.clientInfo ? { clientInfo: row.clientInfo as StoredClientInfo } : {}),
...(row.codeVerifier ? { codeVerifier: row.codeVerifier } : {}),
...(row.oauthState ? { oauthState: row.oauthState } : {}),
}
let pendingAuth: PendingAuth | undefined
if (row.pendingAuth && typeof row.pendingAuth === 'object') {
const raw = row.pendingAuth as Partial<PendingAuth>
if (typeof raw.state === 'string' && typeof raw.expiresAt === 'number') {
pendingAuth = {
state: raw.state,
authorizationUrl: raw.authorizationUrl ?? '',
discovery: raw.discovery ?? {},
expiresAt: raw.expiresAt,
...(raw.grantType ? { grantType: raw.grantType } : {}),
...(raw.redirectUri ? { redirectUri: raw.redirectUri } : {}),
}
}
}
return { entry, pendingAuth }
}
/**
* DB-backed credential store for MCP OAuth state (port of pi-mcp-adapter's
* mcp-auth.ts storage layer, replacing the OS keyring/files with an
* `McpServerCredential` row per server).
*/
export class McpDbStore {
constructor(private readonly prismaClient: typeof prisma = prisma) {}
private async getRow(serverId: string) {
return this.prismaClient.mcpServerCredential.findUnique({
where: { serverId },
})
}
private async ensureRow(serverId: string, serverUrl?: string) {
const existing = await this.getRow(serverId)
if (existing) return existing
if (!serverUrl) throw new Error(`No credential row for MCP server ${serverId}`)
return this.prismaClient.mcpServerCredential.create({
data: {
serverId,
serverUrl,
},
})
}
/**
* Get the auth entry for a server, validated against the current URL.
* Returns undefined when no entry exists or the URL changed (credentials invalid).
*/
async getAuthForUrl(serverId: string, serverUrl: string): Promise<AuthEntry | undefined> {
const row = await this.getRow(serverId)
if (!row) return undefined
// If no serverUrl is stored or it changed, credentials are invalid.
if (!row.serverUrl || row.serverUrl !== serverUrl) return undefined
return rowToAuthEntry(row).entry
}
async getAuthEntry(serverId: string): Promise<AuthEntry | undefined> {
const row = await this.getRow(serverId)
if (!row) return undefined
return rowToAuthEntry(row).entry
}
async saveAuthEntry(serverId: string, entry: AuthEntry, serverUrl?: string): Promise<void> {
const row = await this.getRow(serverId)
const serverUrlValue = serverUrl ?? entry.serverUrl ?? row?.serverUrl
// Do NOT merge the row's credential fields back in: callers build `entry`
// from getAuthEntry() (all current fields) and delete fields to clear
// them. Re-adding row fields would leak cleared values.
const merged: AuthEntry = { ...entry }
if (serverUrlValue) {
merged.serverUrl = serverUrlValue
if (row && serverUrlValue !== row.serverUrl) {
// URL changed: stale sub-credentials are dropped.
delete merged.tokens
delete merged.clientInfo
delete merged.codeVerifier
delete merged.oauthState
}
}
const data = {
serverUrl: merged.serverUrl ?? serverUrlValue ?? '',
tokens: merged.tokens ?? undefined,
clientInfo: merged.clientInfo ?? undefined,
codeVerifier: merged.codeVerifier ?? undefined,
oauthState: merged.oauthState ?? undefined,
}
if (row) {
await this.prismaClient.mcpServerCredential.update({
where: { serverId },
data: {
serverUrl: data.serverUrl,
tokens:
data.tokens === undefined
? Prisma.JsonNull
: (data.tokens as PrismaJson.McpStoredTokens),
clientInfo:
data.clientInfo === undefined
? Prisma.JsonNull
: (data.clientInfo as PrismaJson.McpStoredClientInfo),
codeVerifier: data.codeVerifier ?? null,
oauthState: data.oauthState ?? null,
},
})
} else if (serverUrlValue) {
await this.prismaClient.mcpServerCredential.create({
data: {
serverId,
serverUrl: serverUrlValue,
tokens: data.tokens as PrismaJson.McpStoredTokens | undefined,
clientInfo: data.clientInfo as PrismaJson.McpStoredClientInfo | undefined,
codeVerifier: data.codeVerifier,
oauthState: data.oauthState,
},
})
}
}
async updateTokens(serverId: string, tokens: StoredTokens, serverUrl?: string): Promise<void> {
const entry = (await this.getAuthEntry(serverId)) ?? {}
if (serverUrl && entry.serverUrl && entry.serverUrl !== serverUrl) {
delete entry.clientInfo
delete entry.codeVerifier
delete entry.oauthState
}
entry.tokens = tokens
await this.saveAuthEntry(serverId, entry, serverUrl)
}
async updateClientInfo(
serverId: string,
clientInfo: StoredClientInfo,
serverUrl?: string,
): Promise<void> {
const entry = (await this.getAuthEntry(serverId)) ?? {}
if (serverUrl && entry.serverUrl && entry.serverUrl !== serverUrl) {
delete entry.tokens
delete entry.codeVerifier
delete entry.oauthState
}
entry.clientInfo = clientInfo
await this.saveAuthEntry(serverId, entry, serverUrl)
}
async updateCodeVerifier(
serverId: string,
codeVerifier: string,
serverUrl?: string,
): Promise<void> {
const entry = (await this.getAuthEntry(serverId)) ?? {}
if (serverUrl && entry.serverUrl && entry.serverUrl !== serverUrl) {
delete entry.tokens
delete entry.clientInfo
delete entry.oauthState
}
entry.codeVerifier = codeVerifier
await this.saveAuthEntry(serverId, entry, serverUrl)
}
async clearCodeVerifier(serverId: string): Promise<void> {
const entry = await this.getAuthEntry(serverId)
if (entry) {
delete entry.codeVerifier
await this.saveAuthEntry(serverId, entry)
}
}
async updateOauthState(serverId: string, state: string, serverUrl?: string): Promise<void> {
const entry = (await this.getAuthEntry(serverId)) ?? {}
if (serverUrl && entry.serverUrl && entry.serverUrl !== serverUrl) {
delete entry.tokens
delete entry.clientInfo
delete entry.codeVerifier
}
entry.oauthState = state
await this.saveAuthEntry(serverId, entry, serverUrl)
}
async getOauthState(serverId: string): Promise<string | undefined> {
const row = await this.getRow(serverId)
return row?.oauthState ?? undefined
}
async clearOauthState(serverId: string): Promise<void> {
const entry = await this.getAuthEntry(serverId)
if (entry) {
delete entry.oauthState
await this.saveAuthEntry(serverId, entry)
}
}
/** Returns null when no tokens exist, false when valid, true when expired. */
async isTokenExpired(serverId: string): Promise<boolean | null> {
const row = await this.getRow(serverId)
const tokens = row?.tokens as StoredTokens | null | undefined
if (!tokens?.accessToken) return null
if (!tokens.expiresAt) return false
return tokens.expiresAt < Date.now() / 1000
}
async hasStoredTokens(serverId: string): Promise<boolean> {
const row = await this.getRow(serverId)
const tokens = row?.tokens as StoredTokens | null | undefined
return !!tokens?.accessToken
}
async clearAllCredentials(serverId: string): Promise<void> {
const row = await this.getRow(serverId)
if (!row) return
await this.prismaClient.mcpServerCredential.delete({ where: { serverId } })
}
async clearClientInfo(serverId: string): Promise<void> {
const entry = await this.getAuthEntry(serverId)
if (entry) {
delete entry.clientInfo
await this.saveAuthEntry(serverId, entry)
}
}
async clearTokens(serverId: string): Promise<void> {
const entry = await this.getAuthEntry(serverId)
if (entry) {
delete entry.tokens
await this.saveAuthEntry(serverId, entry)
}
}
// --------------------------------------------------------------------------
// In-flight authorization_code flow (pendingAuth)
// --------------------------------------------------------------------------
async savePendingAuth(serverId: string, pending: PendingAuth): Promise<void> {
const row = await this.getRow(serverId)
if (!row) {
const server = await this.prismaClient.mcpServer.findUnique({
where: { id: serverId },
select: { url: true },
})
if (!server) throw new Error(`MCP server ${serverId} not found`)
await this.ensureRow(serverId, server.url)
}
// Preserve an in-flight discovery snapshot: the OAuth provider's
// saveDiscoveryState() lives in the same JSON column, and the callback
// leg needs it for the SEP-2352 issuer check.
const existing = (row?.pendingAuth as Record<string, unknown> | null | undefined) ?? {}
const discoverySnapshot = existing['discoverySnapshot']
const data = discoverySnapshot !== undefined ? { ...pending, discoverySnapshot } : pending
await this.prismaClient.mcpServerCredential.update({
where: { serverId },
data: { pendingAuth: data as unknown as PrismaJson.McpPendingAuth },
})
}
async getPendingAuth(serverId: string): Promise<PendingAuth | undefined> {
const row = await this.getRow(serverId)
if (!row) return undefined
const { pendingAuth } = rowToAuthEntry(row)
if (!pendingAuth) return undefined
if (pendingAuth.expiresAt < Date.now() / 1000) {
await this.clearPendingAuth(serverId)
return undefined
}
return pendingAuth
}
async clearPendingAuth(serverId: string): Promise<void> {
const row = await this.getRow(serverId)
if (!row) return
await this.prismaClient.mcpServerCredential.update({
where: { serverId },
data: { pendingAuth: Prisma.JsonNull },
})
}
async getPendingAuthTtlSeconds(): Promise<number> {
return PENDING_AUTH_TTL_SECONDS
}
/** Ensure a credential row exists for a server (used when persisting any auth state). */
async ensureCredentialRow(serverId: string, serverUrl: string): Promise<void> {
await this.ensureRow(serverId, serverUrl)
}
// --------------------------------------------------------------------------
// Discovery snapshot (survives from startAuth to the callback leg)
// --------------------------------------------------------------------------
async saveDiscoverySnapshot(serverId: string, serverUrl: string, state: unknown): Promise<void> {
await this.ensureRow(serverId, serverUrl)
const row = await this.getRow(serverId)
const existing = (row?.pendingAuth as Record<string, unknown> | null | undefined) ?? {}
await this.prismaClient.mcpServerCredential.update({
where: { serverId },
data: {
pendingAuth: {
...existing,
discoverySnapshot: state,
} as unknown as PrismaJson.McpPendingAuth,
},
})
}
async getDiscoverySnapshot(serverId: string): Promise<Record<string, unknown> | undefined> {
const row = await this.getRow(serverId)
const pending = (row?.pendingAuth as Record<string, unknown> | null | undefined) ?? {}
const snapshot = pending['discoverySnapshot']
return snapshot && typeof snapshot === 'object'
? (snapshot as Record<string, unknown>)
: undefined
}
async clearDiscoverySnapshot(serverId: string): Promise<void> {
const row = await this.getRow(serverId)
if (!row) return
const pending = (row.pendingAuth as Record<string, unknown> | null | undefined) ?? {}
const rest: Record<string, unknown> = { ...pending }
delete rest['discoverySnapshot']
await this.prismaClient.mcpServerCredential.update({
where: { serverId },
data: {
pendingAuth:
Object.keys(rest).length > 0
? (rest as unknown as PrismaJson.McpPendingAuth)
: Prisma.JsonNull,
},
})
}
}
export const mcpDbStore = new McpDbStore()
+87
View File
@@ -0,0 +1,87 @@
/**
* Direct MCP tools — per-server opt-in registration.
*
* When a server's config sets `directTools` to an array of tool names, its
* allowed tools (matching the original or `{server}_{tool}` prefixed name,
* after excludeTools filters) are registered as native AgentTools with
* prefixed names `{server}_{tool}`. The `mcp` proxy tool stays registered for
* discovery/auth/status and for tools not in direct mode.
*/
import { Type } from '@sinclair/typebox'
import type { AgentTool, AgentToolResult } from '@earendil-works/pi-agent-core'
import '@shumai/db/src/prisma-json-types'
import type { ToolMetadata } from './mcp-tool-registry'
import { isToolAllowed } from './mcp-tool-registry'
import { toToolParameters } from './mcp-tool-schema'
export interface DirectToolCallOptions {
serverId: string
serverName: string
callTool(
serverId: string,
toolName: string,
args: Record<string, unknown>,
): Promise<{
ok: boolean
content: AgentToolResult<Record<string, unknown>>['content']
}>
}
/**
* Decide whether a tool is exposed as a native direct tool. Matches the
* original MCP name or the `{server}_{tool}` prefixed name against the
* configured directTools array. Shared by direct registration and the proxy
* description counts so the two can never drift apart.
*/
export function isDirectTool(
originalName: string,
prefixedName: string,
directTools?: string[],
): boolean {
if (!Array.isArray(directTools)) return false
return directTools.includes(originalName) || directTools.includes(prefixedName)
}
/**
* Build direct AgentTools for a server in direct-tools mode.
* Returns [] when directTools is not enabled or no tools pass the filters.
*/
export function buildDirectTools(
metadata: ToolMetadata[],
config: PrismaJson.McpServerConfig | undefined,
opts: DirectToolCallOptions,
): AgentTool[] {
const directTools = config?.directTools
if (!Array.isArray(directTools) || directTools.length === 0) return []
const tools: AgentTool[] = []
for (const tool of metadata) {
if (!isToolAllowed(tool.name, tool.originalName, config?.excludeTools)) continue
if (!isDirectTool(tool.originalName, tool.name, directTools)) continue
const parameters = toToolParameters(tool.inputSchema)
tools.push({
name: tool.name,
label: tool.name,
description:
tool.description || `Call ${tool.originalName} on MCP server ${opts.serverName}.`,
parameters: parameters as unknown as import('typebox').TSchema,
execute: async (_toolCallId, args): Promise<AgentToolResult<Record<string, unknown>>> => {
const result = await opts.callTool(
opts.serverId,
tool.originalName,
args as Record<string, unknown>,
)
return {
content: result.content,
details: { server: opts.serverName, tool: tool.originalName },
}
},
})
}
return tools
}
// Re-exported for tests that need a fallback parameter schema.
export { Type }
@@ -0,0 +1,147 @@
import { describe, it, expect, beforeAll } from 'vitest'
import { prisma } from '@shumai/db'
import { setupTestDbHooks } from '@shumai/db/test'
import { McpDbStore } from './mcp-db-store'
import { McpOauthProvider } from './mcp-oauth-provider'
/* eslint-disable @typescript-eslint/naming-convention */
// The OAuth wire format (RFC 6749 / OAuth 2.1) uses snake_case field names
// (client_id, access_token, grant_type, ...); the test fixtures must use the
// protocol's exact key names because they are passed to the MCP SDK's
// OAuthClientProvider interfaces.
const SERVER_URL = 'https://mcp.example.com/kling'
const ISSUER = 'https://kling.ai/auth'
describe('McpOauthProvider SEP-2352 issuer stamping', () => {
setupTestDbHooks()
let store: McpDbStore
let serverId: string
const makeProvider = () =>
new McpOauthProvider(
serverId,
SERVER_URL,
{ redirectUri: 'https://shumai.ai/api/mcp/oauth/callback' },
{ onRedirect: async () => {} },
store,
)
beforeAll(async () => {
store = new McpDbStore()
const team = await prisma.team.create({ data: { name: 'OAuth Provider Team' } })
const server = await prisma.mcpServer.create({
data: { name: 'kling', url: SERVER_URL, teamId: team.id },
})
serverId = server.id
})
it('discoveryState() returns the snapshot saved by the start leg on the callback leg', async () => {
const provider = makeProvider()
// Start leg: the SDK saves the discovery state before redirecting.
await provider.saveDiscoveryState({
authorizationServerUrl: ISSUER,
authorizationServerMetadata: { issuer: ISSUER },
resourceMetadataUrl: `${SERVER_URL}/.well-known/oauth-protected-resource`,
} as never)
await provider.deactivate()
// startAuth() persists the pending flow (must not clobber the snapshot).
await store.savePendingAuth(serverId, {
state: 'state-xyz',
authorizationUrl: 'https://kling.ai/authorize',
discovery: {},
expiresAt: Math.floor(Date.now() / 1000) + 300,
})
// Callback leg: a fresh provider instance reads the same snapshot.
const callbackProvider = makeProvider()
const state = await callbackProvider.discoveryState()
expect(state?.authorizationServerMetadata?.issuer).toBe(ISSUER)
expect(state?.authorizationServerUrl).toBe(ISSUER)
})
it('saveClientInformation stamps the issuer and clientInformation round-trips it', async () => {
const provider = makeProvider()
await provider.saveDiscoveryState({
authorizationServerUrl: ISSUER,
authorizationServerMetadata: { issuer: ISSUER },
} as never)
await provider.saveClientInformation({
client_id: 'dyn-client',
client_secret: 'dyn-secret',
} as never)
const info = await makeProvider().clientInformation()
expect(info?.client_id).toBe('dyn-client')
expect((info as { issuer?: string }).issuer).toBe(ISSUER)
})
it('clientInformation() backfills a missing issuer stamp on stale client info', async () => {
const provider = makeProvider()
// Pre-existing client info stored WITHOUT an issuer (registered before the
// stamping fix). The discovery snapshot is available for this read.
await store.updateClientInfo(
serverId,
{ clientId: 'legacy-client', clientSecret: 'legacy-secret' },
SERVER_URL,
)
await provider.saveDiscoveryState({
authorizationServerUrl: ISSUER,
authorizationServerMetadata: { issuer: ISSUER },
} as never)
const info = await makeProvider().clientInformation()
expect(info?.client_id).toBe('legacy-client')
expect((info as { issuer?: string }).issuer).toBe(ISSUER)
// The stamp is persisted, not just returned.
const entry = await store.getAuthForUrl(serverId, SERVER_URL)
expect(entry?.clientInfo?.issuer).toBe(ISSUER)
})
it('saveTokens stamps the issuer and tokens round-trips it', async () => {
const provider = makeProvider()
await provider.saveDiscoveryState({
authorizationServerUrl: ISSUER,
authorizationServerMetadata: { issuer: ISSUER },
} as never)
await provider.saveTokens({
access_token: 'tok-1',
token_type: 'Bearer',
refresh_token: 'ref-1',
expires_in: 3600,
} as never)
const tokens = await makeProvider().tokens()
expect(tokens?.access_token).toBe('tok-1')
expect((tokens as { issuer?: string }).issuer).toBe(ISSUER)
})
it('tokens() backfills a missing issuer stamp from the discovery snapshot', async () => {
const provider = makeProvider()
// Pre-existing tokens stored WITHOUT an issuer (pre-upgrade / buggy flow).
await store.updateTokens(serverId, { accessToken: 'legacy-tok' }, SERVER_URL)
// The discovery snapshot is present for the read.
await provider.saveDiscoveryState({
authorizationServerUrl: ISSUER,
authorizationServerMetadata: { issuer: ISSUER },
} as never)
const tokens = await provider.tokens()
expect(tokens?.access_token).toBe('legacy-tok')
expect((tokens as { issuer?: string }).issuer).toBe(ISSUER)
// The stamp is persisted, not just returned.
const entry = await store.getAuthForUrl(serverId, SERVER_URL)
expect(entry?.tokens?.issuer).toBe(ISSUER)
})
it('does not stamp an issuer when no discovery snapshot is available', async () => {
const provider = makeProvider()
await provider.saveClientInformation({ client_id: 'c2' } as never)
const info = await makeProvider().clientInformation()
expect((info as { issuer?: string }).issuer).toBeUndefined()
})
})
+503
View File
@@ -0,0 +1,503 @@
/**
* MCP OAuth Provider (DB-backed)
*
* Implementation of the MCP SDK's OAuthClientProvider interface. Adapted from
* pi-mcp-adapter's mcp-oauth-provider.ts, with two differences:
* 1. All persisted state (tokens, client info, PKCE verifier, discovery
* state, CSRF state) is stored in the DB via McpDbStore instead of the OS
* keyring/files, so the flow survives across HTTP requests and processes.
* 2. The redirect URI is shumai's own Hono callback endpoint
* (`${MCP_OAUTH_REDIRECT_BASE_URL}/api/mcp/oauth/callback`) instead of a
* localhost callback server.
*/
/* eslint-disable @typescript-eslint/naming-convention */
// The OAuth wire format (RFC 6749 / OAuth 2.1 client metadata) uses snake_case
// field names (client_id, access_token, grant_type, ...). These are dictated by
// the OAuth protocol and the MCP SDK's OAuthClientProvider interfaces, so they
// cannot be renamed to camelCase.
import {
type AddClientAuthentication,
type OAuthClientProvider,
type OAuthClientInformationMixed,
type OAuthClientMetadata,
type OAuthDiscoveryState,
type OAuthTokens,
} from '@modelcontextprotocol/client'
import type { McpDbStore, AuthEntry, StoredClientInfo, StoredTokens } from './mcp-db-store'
type IssuerBoundClientInformation = OAuthClientInformationMixed & { issuer?: string }
type IssuerBoundTokens = OAuthTokens & { issuer?: string }
function issuersMatch(first: string, second: string): boolean {
return (
first === second ||
(first.endsWith('/') && first.slice(0, -1) === second) ||
(second.endsWith('/') && second.slice(0, -1) === first)
)
}
export function getOauthRedirectBaseUrl(): string {
return (
process.env.MCP_OAUTH_REDIRECT_BASE_URL?.trim() || process.env.BETTER_AUTH_URL?.trim() || ''
)
}
/** The default redirect URI used when the server config does not set one. */
export function getDefaultOauthRedirectUri(): string | undefined {
const base = getOauthRedirectBaseUrl()
if (!base) return undefined
return `${base.replace(/\/$/, '')}/api/mcp/oauth/callback`
}
/** Configuration options for OAuth. */
export interface McpOauthConfig {
grantType?: 'authorization_code' | 'client_credentials'
clientId?: string
clientSecret?: string
scope?: string
authorizationParams?: Record<string, string>
redirectUri?: string
clientName?: string
clientUri?: string
skipIssuerMetadataValidation?: boolean
}
const reservedAuthorizationParams = new Set([
'client_id',
'code_challenge',
'code_challenge_method',
'redirect_uri',
'resource',
'response_type',
'scope',
'state',
])
function addAuthorizationParams(
authorizationUrl: URL,
params: Record<string, string> | undefined,
): URL {
if (!params) return authorizationUrl
const nextUrl = new URL(authorizationUrl.toString())
for (const [key, value] of Object.entries(params)) {
if (reservedAuthorizationParams.has(key) || nextUrl.searchParams.has(key)) {
throw new Error(
`OAuth authorizationParams.${key} cannot override an authorization flow parameter`,
)
}
nextUrl.searchParams.set(key, value)
}
return nextUrl
}
/** Callbacks for OAuth flow interactions. */
export interface McpOauthCallbacks {
onRedirect: (url: URL) => void | Promise<void>
}
/**
* OAuth provider implementation for MCP servers backed by the DB store.
*/
export class McpOauthProvider implements OAuthClientProvider {
private readonly redirectUrlSnapshot: string | undefined
private active = true
private flowIssuerMismatch = false
constructor(
private serverId: string,
private serverUrl: string,
private config: McpOauthConfig,
private callbacks: McpOauthCallbacks,
private store: McpDbStore,
) {
this.redirectUrlSnapshot =
config.grantType === 'client_credentials'
? undefined
: (config.redirectUri ?? getDefaultOauthRedirectUri())
}
private get usesClientCredentials(): boolean {
return this.config.grantType === 'client_credentials'
}
deactivate(): void {
this.active = false
}
private throwIfInactive(): void {
if (!this.active) throw new Error('OAuth flow is no longer active')
}
private assertStoredIssuerBindings(
entry: AuthEntry | undefined,
issuer: string | undefined,
): void {
if (this.flowIssuerMismatch) {
throw new Error(
`OAuth authorization server issuer changed; clear credentials before authenticating again`,
)
}
if (!entry || !issuer) return
const storedIssuers = [entry.clientInfo?.issuer, entry.tokens?.issuer].filter(
(storedIssuer): storedIssuer is string => storedIssuer !== undefined,
)
if (storedIssuers.some((storedIssuer) => !issuersMatch(storedIssuer, issuer))) {
this.flowIssuerMismatch = true
throw new Error(
`OAuth authorization server issuer changed; clear credentials before authenticating again`,
)
}
}
/** The redirect URL for OAuth callbacks. */
get redirectUrl(): string | undefined {
return this.redirectUrlSnapshot
}
/**
* SEP-2352 issuer of the authorization server from the discovery snapshot
* persisted by saveDiscoveryState (available on both the start and callback
* legs thanks to the DB-backed store).
*/
private async getDiscoveredIssuer(): Promise<string | undefined> {
const snapshot = await this.store.getDiscoverySnapshot(this.serverId)
if (!snapshot) return undefined
const metadata = snapshot['authorizationServerMetadata'] as { issuer?: string } | undefined
const issuer = metadata?.issuer
if (typeof issuer === 'string' && issuer.length > 0) return issuer
const serverUrl = snapshot['authorizationServerUrl']
return typeof serverUrl === 'string' && serverUrl.length > 0 ? serverUrl : undefined
}
/** Client metadata for dynamic registration. */
get clientMetadata(): OAuthClientMetadata {
if (this.usesClientCredentials) {
return {
client_name: this.config.clientName ?? 'Shumai',
client_uri: this.config.clientUri ?? 'https://shumai.ai',
redirect_uris: [],
grant_types: ['client_credentials'],
token_endpoint_auth_method: this.config.clientSecret ? 'client_secret_post' : 'none',
}
}
const redirectUrl = this.redirectUrl
if (!redirectUrl) {
throw new Error(
'redirectUrl is required for authorization_code flow. Set MCP_OAUTH_REDIRECT_BASE_URL or BETTER_AUTH_URL, or configure authConfig.oauth.redirectUri.',
)
}
return {
redirect_uris: [redirectUrl],
client_name: this.config.clientName ?? 'Shumai',
client_uri: this.config.clientUri ?? 'https://shumai.ai',
grant_types: ['authorization_code', 'refresh_token'],
response_types: ['code'],
token_endpoint_auth_method: this.config.clientSecret ? 'client_secret_post' : 'none',
...(this.config.scope !== undefined ? { scope: this.config.scope } : {}),
}
}
/** Get client information (pre-registered or dynamically registered). */
async clientInformation(): Promise<OAuthClientInformationMixed | undefined> {
const stored = await this.store.getAuthForUrl(this.serverId, this.serverUrl)
this.assertStoredIssuerBindings(stored, undefined)
// Config-first (pre-registered client). The secret stays in config.
if (this.config.clientId) {
const storedClient =
stored?.clientInfo?.clientId === this.config.clientId ? stored.clientInfo : undefined
const issuer = await this.getDiscoveredIssuer()
if (storedClient?.issuer === undefined || storedClient.configPreRegistered !== true) {
await this.store.updateClientInfo(
this.serverId,
{
clientId: this.config.clientId,
configPreRegistered: true,
...(issuer !== undefined ? { issuer } : {}),
},
this.serverUrl,
)
}
return {
client_id: this.config.clientId,
client_secret: this.config.clientSecret,
...(issuer !== undefined ? { issuer } : {}),
} as IssuerBoundClientInformation
}
const clientInfo = stored?.clientInfo
if (clientInfo) {
const isConfigStub =
clientInfo.configPreRegistered === true ||
(clientInfo.clientSecret === undefined &&
clientInfo.clientIdIssuedAt === undefined &&
clientInfo.clientSecretExpiresAt === undefined &&
clientInfo.redirectUris === undefined)
if (isConfigStub) return undefined
if (
clientInfo.clientSecretExpiresAt &&
clientInfo.clientSecretExpiresAt < Date.now() / 1000
) {
return undefined
}
// SEP-2352: backfill a missing issuer stamp (pre-upgrade / stale storage)
// from the discovery snapshot, persisting it so later reads are isolated.
const issuer = await this.getDiscoveredIssuer()
if (issuer !== undefined && clientInfo.issuer === undefined) {
const stamped: StoredClientInfo = { ...clientInfo, issuer }
await this.store.updateClientInfo(this.serverId, stamped, this.serverUrl)
clientInfo.issuer = issuer
}
return {
client_id: clientInfo.clientId,
client_secret: clientInfo.clientSecret,
...(clientInfo.clientIdIssuedAt !== undefined
? { client_id_issued_at: clientInfo.clientIdIssuedAt }
: {}),
...(clientInfo.clientSecretExpiresAt !== undefined
? { client_secret_expires_at: clientInfo.clientSecretExpiresAt }
: {}),
...(clientInfo.redirectUris !== undefined
? { redirect_uris: clientInfo.redirectUris }
: {}),
...(clientInfo.issuer !== undefined ? { issuer: clientInfo.issuer } : {}),
} as IssuerBoundClientInformation
}
// No client info - triggers dynamic registration.
return undefined
}
/** Save client information from dynamic registration. */
async saveClientInformation(info: OAuthClientInformationMixed): Promise<void> {
this.throwIfInactive()
if (this.config.clientId && info.client_id === this.config.clientId) {
await this.store.updateClientInfo(
this.serverId,
{ clientId: info.client_id, configPreRegistered: true },
this.serverUrl,
)
return
}
const redirectUris =
('redirect_uris' in info ? info.redirect_uris : undefined) ??
(this.redirectUrl ? [this.redirectUrl] : undefined)
const issuer = await this.getDiscoveredIssuer()
const clientInfo: StoredClientInfo = {
clientId: info.client_id,
...(info.client_secret !== undefined ? { clientSecret: info.client_secret } : {}),
...(info.client_id_issued_at !== undefined
? { clientIdIssuedAt: info.client_id_issued_at }
: {}),
...(info.client_secret_expires_at !== undefined
? { clientSecretExpiresAt: info.client_secret_expires_at }
: {}),
...(redirectUris !== undefined ? { redirectUris } : {}),
...(issuer !== undefined ? { issuer } : {}),
}
await this.store.updateClientInfo(this.serverId, clientInfo, this.serverUrl)
}
/** Get stored OAuth tokens. */
async tokens(): Promise<OAuthTokens | undefined> {
const entry = await this.store.getAuthForUrl(this.serverId, this.serverUrl)
if (!entry?.tokens) return undefined
this.assertStoredIssuerBindings(entry, undefined)
// SEP-2352: backfill a missing issuer stamp from the discovery snapshot so
// isolation stays active for pre-existing credentials.
const issuer = await this.getDiscoveredIssuer()
if (issuer !== undefined && entry.tokens.issuer === undefined) {
const stamped: StoredTokens = { ...entry.tokens, issuer }
await this.store.updateTokens(this.serverId, stamped, this.serverUrl)
entry.tokens = stamped
}
return {
access_token: entry.tokens.accessToken,
token_type: 'Bearer',
refresh_token: entry.tokens.refreshToken,
expires_in: entry.tokens.expiresAt
? Math.max(0, Math.floor(entry.tokens.expiresAt - Date.now() / 1000))
: undefined,
scope: entry.tokens.scope,
...(entry.tokens.issuer !== undefined ? { issuer: entry.tokens.issuer } : {}),
} as IssuerBoundTokens
}
/** Save OAuth tokens. */
async saveTokens(tokens: OAuthTokens): Promise<void> {
const issuer = await this.getDiscoveredIssuer()
const storedTokens: StoredTokens = {
accessToken: tokens.access_token,
...(tokens.refresh_token !== undefined ? { refreshToken: tokens.refresh_token } : {}),
...(tokens.expires_in !== undefined
? { expiresAt: Date.now() / 1000 + tokens.expires_in }
: {}),
...(tokens.scope !== undefined ? { scope: tokens.scope } : {}),
...(issuer !== undefined ? { issuer } : {}),
}
this.throwIfInactive()
await this.store.updateTokens(this.serverId, storedTokens, this.serverUrl)
}
/** Redirect the user to the authorization URL. */
async redirectToAuthorization(authorizationUrl: URL): Promise<void> {
if (this.usesClientCredentials) {
throw new Error('redirectToAuthorization is not used for client_credentials flow')
}
this.throwIfInactive()
await this.callbacks.onRedirect(
addAuthorizationParams(authorizationUrl, this.config.authorizationParams),
)
}
/** Save the PKCE code verifier (persisted so the callback leg can use it). */
async saveCodeVerifier(codeVerifier: string): Promise<void> {
this.throwIfInactive()
await this.store.updateCodeVerifier(this.serverId, codeVerifier, this.serverUrl)
}
async codeVerifier(): Promise<string> {
if (this.usesClientCredentials) {
throw new Error('codeVerifier is not used for client_credentials flow')
}
this.throwIfInactive()
const entry = await this.store.getAuthForUrl(this.serverId, this.serverUrl)
if (!entry?.codeVerifier) {
throw new Error(`No code verifier saved for MCP server`)
}
return entry.codeVerifier
}
/** Keep discovery with the in-flight PKCE verifier. */
async saveDiscoveryState(state: OAuthDiscoveryState): Promise<void> {
this.throwIfInactive()
// Persisted inside the pendingAuth row by mcpService after startAuth; also
// kept on the credential row so the callback leg can re-read it.
await this.store.saveDiscoverySnapshot(this.serverId, this.serverUrl, state)
}
async discoveryState(): Promise<OAuthDiscoveryState | undefined> {
this.throwIfInactive()
const snapshot = await this.store.getDiscoverySnapshot(this.serverId)
return snapshot as unknown as OAuthDiscoveryState | undefined
}
/** Save the OAuth state parameter for CSRF protection. */
async saveState(state: string): Promise<void> {
this.throwIfInactive()
await this.store.updateOauthState(this.serverId, state, this.serverUrl)
}
async state(): Promise<string> {
if (this.usesClientCredentials) {
throw new Error('state is not used for client_credentials flow')
}
this.throwIfInactive()
let state = await this.store.getOauthState(this.serverId)
if (!state) {
state = Array.from(crypto.getRandomValues(new Uint8Array(32)))
.map((b) => b.toString(16).padStart(2, '0'))
.join('')
await this.store.updateOauthState(this.serverId, state, this.serverUrl)
}
return state
}
/** Invalidate credentials when authentication fails. */
async invalidateCredentials(
type: 'all' | 'client' | 'tokens' | 'verifier' | 'discovery',
): Promise<void> {
this.throwIfInactive()
switch (type) {
case 'all':
this.flowIssuerMismatch = false
await this.store.clearAllCredentials(this.serverId)
break
case 'client':
await this.store.clearClientInfo(this.serverId)
break
case 'tokens':
await this.store.clearTokens(this.serverId)
break
case 'verifier':
await this.store.clearCodeVerifier(this.serverId)
break
case 'discovery':
await this.store.clearDiscoverySnapshot(this.serverId)
break
}
}
/** Adds configured authorization-code scope and client authentication. */
addClientAuthentication: AddClientAuthentication = async (headers, params, _url, metadata) => {
this.throwIfInactive()
if (
params.get('grant_type') === 'authorization_code' &&
!params.has('scope') &&
this.config.scope
) {
params.set('scope', this.config.scope)
}
const clientInfo = await this.clientInformation()
this.throwIfInactive()
if (!clientInfo) return
const supportedMethods = metadata?.token_endpoint_auth_methods_supported ?? []
const hasClientSecret = clientInfo.client_secret !== undefined
let authMethod: 'client_secret_basic' | 'client_secret_post' | 'none'
if (supportedMethods.length === 0) {
authMethod = hasClientSecret ? 'client_secret_post' : 'none'
} else if (hasClientSecret && supportedMethods.includes('client_secret_basic')) {
authMethod = 'client_secret_basic'
} else if (hasClientSecret && supportedMethods.includes('client_secret_post')) {
authMethod = 'client_secret_post'
} else if (supportedMethods.includes('none')) {
authMethod = 'none'
} else {
authMethod = hasClientSecret ? 'client_secret_post' : 'none'
}
if (authMethod === 'client_secret_basic') {
if (!clientInfo.client_secret) {
throw new Error('client_secret_basic authentication requires a client_secret')
}
headers.set(
'Authorization',
`Basic ${Buffer.from(`${clientInfo.client_id}:${clientInfo.client_secret}`).toString('base64')}`,
)
return
}
if (!params.has('client_id')) {
params.set('client_id', clientInfo.client_id)
}
if (
authMethod === 'client_secret_post' &&
clientInfo.client_secret &&
!params.has('client_secret')
) {
params.set('client_secret', clientInfo.client_secret)
}
}
prepareTokenRequest(scope?: string): URLSearchParams | undefined {
if (!this.usesClientCredentials) return undefined
const params = new URLSearchParams({ grant_type: 'client_credentials' })
const requestedScope = scope ?? this.config.scope
if (requestedScope) {
params.set('scope', requestedScope)
}
return params
}
}
+510
View File
@@ -0,0 +1,510 @@
/**
* MCP proxy tool — the single `mcp` AgentTool registered per agent.
*
* One tool in the LLM context multiplexes all of the agent's assigned MCP
* servers via `{ server, tool, args, search, describe, connect, action }`.
* Mode precedence: action > tool(call) > connect > describe > search >
* server(list) > status.
*/
import { Type } from '@sinclair/typebox'
import type { AgentTool, AgentToolResult } from '@earendil-works/pi-agent-core'
import type { McpToolRegistry, ToolMetadata } from './mcp-tool-registry'
import { formatSchema } from './mcp-tool-schema'
type ProxyToolResult = AgentToolResult<Record<string, unknown>>
/** Truncated instructions head baked into the proxy tool description (L1). */
const INSTRUCTIONS_SNIPPET_LENGTH = 150
/** Longer instructions preview appended to server listings (L2). */
const INSTRUCTIONS_PREVIEW_LENGTH = 300
/** Truncate at a word boundary (mirrors pi-mcp-adapter's truncateAtWord). */
function truncateInstruction(text: string, target: number): string {
if (!text || text.length <= target) return text
const truncated = text.slice(0, target)
const lastSpace = truncated.lastIndexOf(' ')
if (lastSpace > target * 0.6) {
return `${truncated.slice(0, lastSpace)}...`
}
return `${truncated}...`
}
export interface ProxyServerInfo {
id: string
name: string
toolCount: number
directToolCount?: number
status: string
/** Self-reported server usage instructions (empty when the server provides none). */
instructions?: string
}
export type ConnectionOutcome =
| { status: 'connected' }
| { status: 'needs-auth' }
| { status: 'error'; message: string }
export interface CallToolOutcome {
ok: boolean
content: AgentToolResult<Record<string, unknown>>['content']
}
export interface McpProxyToolContext {
teamId: string
userId?: string
servers: ProxyServerInfo[]
serverNameById: Map<string, string>
serverIdByName: Map<string, string>
registry: McpToolRegistry
/** Resolve the server id for a (possibly prefixed) tool name. */
resolveServerForTool?(toolName: string): string | undefined
ensureConnected(serverId: string): Promise<ConnectionOutcome>
callTool(
serverId: string,
toolName: string,
args: Record<string, unknown>,
): Promise<CallToolOutcome>
authStatus(serverId: string): Promise<string>
startAuth(
serverId: string,
): Promise<{ authorizationUrl?: string; alreadyAuthenticated?: boolean }>
/** Server-reported usage instructions (DB cache, works without a live connection). */
getInstructions(serverId: string): Promise<string | null>
}
/**
* Resolve a tool, lazily connecting the owning server first when the registry
* has no cached metadata for it yet (first call in a fresh process).
*/
async function resolveToolWithLazyConnect(
ctx: McpProxyToolContext,
toolName: string,
serverId?: string,
): Promise<{ ok: true; serverId: string; tool: ToolMetadata } | { ok: false }> {
const firstResolve = ctx.registry.findTool(toolName, serverId)
if (firstResolve) return { ok: true, ...firstResolve }
const targetServerId = serverId ?? ctx.resolveServerForTool?.(toolName)
if (!targetServerId) return { ok: false }
const outcome = await ctx.ensureConnected(targetServerId)
if (outcome.status !== 'connected') return { ok: false }
const retried = ctx.registry.findTool(toolName, targetServerId)
if (!retried) return { ok: false }
return { ok: true, ...retried }
}
const proxyToolSchema = Type.Object(
{
server: Type.Optional(
Type.String({
description:
'The MCP server name. Required to call a tool, list a server, or start auth. Omit to search across all servers.',
}),
),
tool: Type.Optional(
Type.String({
description:
'The name of the tool to call on the server (prefixed "{server}_{tool}" or the original tool name).',
}),
),
args: Type.Optional(
Type.Unknown({
description: 'Arguments for the tool call: either a JSON object or a JSON-encoded string.',
}),
),
describe: Type.Optional(
Type.String({
description: 'Tool name to show its full parameter schema.',
}),
),
instructions: Type.Optional(
Type.String({
description: 'Server name to show its full usage instructions.',
}),
),
search: Type.Optional(
Type.String({
description: 'Search query to find tools across servers (camelCase/snake_case aware).',
}),
),
includeSchemas: Type.Optional(
Type.Boolean({
description: 'Include parameter schemas in search results (default true).',
}),
),
limit: Type.Optional(Type.Number({ description: 'Max results for search/list (default 12).' })),
offset: Type.Optional(Type.Number({ description: 'Pagination offset for search/list.' })),
action: Type.Optional(
Type.Union([Type.Literal('status'), Type.Literal('auth-start')], {
description:
'"status" shows connection/auth state for all servers; "auth-start" begins OAuth for `server` (the user completes it in a browser, then you poll status).',
}),
),
},
{ additionalProperties: false },
)
function parseArgs(raw: unknown): Record<string, unknown> {
if (raw === undefined || raw === null) return {}
if (typeof raw === 'string') {
const trimmed = raw.trim()
if (!trimmed) return {}
try {
const parsed = JSON.parse(trimmed)
if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
return parsed as Record<string, unknown>
}
return { value: parsed }
} catch {
return { value: raw }
}
}
if (typeof raw === 'object' && !Array.isArray(raw)) {
return raw as Record<string, unknown>
}
return { value: raw }
}
function contentText(text: string): ProxyToolResult {
return { content: [{ type: 'text', text }], details: {} }
}
/** Transform MCP content blocks into model content blocks. */
export function transformMcpContent(
content: Array<{
type: string
text?: string
data?: string
mimeType?: string
resource?: unknown
uri?: string
name?: string
}>,
): AgentToolResult<Record<string, unknown>>['content'] {
return content.map((c) => {
if (c.type === 'text') {
return { type: 'text', text: c.text ?? '' }
}
if (c.type === 'image') {
return { type: 'image', data: c.data ?? '', mimeType: c.mimeType ?? 'image/png' }
}
if (c.type === 'resource') {
const res = (c.resource ?? {}) as { uri?: string; text?: string }
const resourceUri = res.uri ?? '(no URI)'
const resourceContent = res.text ?? (c.resource ? JSON.stringify(c.resource) : '(no content)')
return { type: 'text', text: `[Resource: ${resourceUri}]\n${resourceContent}` }
}
if (c.type === 'resource_link') {
const linkName = c.name ?? c.uri ?? 'unknown'
const linkUri = c.uri ?? '(no URI)'
return { type: 'text', text: `[Resource Link: ${linkName}]\nURI: ${linkUri}` }
}
if (c.type === 'audio') {
return { type: 'text', text: `[Audio content: ${c.mimeType ?? 'audio/*'}]` }
}
return { type: 'text', text: JSON.stringify(c) }
})
}
function renderToolShape(tool: ToolMetadata, indent = ''): string {
if (!tool.inputSchema) return 'No parameters defined.'
const schemaText = formatSchema(tool.inputSchema, indent)
return `Parameters:\n${schemaText}`
}
function notFoundResult(
toolName: string,
suggestions: string[],
serverName?: string,
): ProxyToolResult {
let msg = `Tool "${toolName}" not found.`
if (serverName) {
msg += ` Use mcp({ server: "${serverName}" }) to list its tools or mcp({ search: "..." }) to search.`
} else {
msg += ` Use mcp({ search: "..." }) to search.`
}
if (suggestions.length > 0) {
msg += ` Did you mean: ${suggestions.join(', ')}`
}
return contentText(msg)
}
/**
* Build the dynamic proxy tool description (server list + tool counts + usage).
* Servers with instructions surface a truncated head so the model sees the
* guidance without making a call; full text is available on demand.
*/
export function buildProxyDescription(servers: ProxyServerInfo[]): string {
const lines: string[] = []
lines.push('Call MCP (Model Context Protocol) tools exposed by the configured servers.')
const directSummaries: string[] = []
for (const s of servers) {
const directCount = s.directToolCount ?? 0
if (directCount > 0) {
directSummaries.push(`${s.name} (${directCount})`)
}
}
if (directSummaries.length > 0) {
lines.push('')
lines.push(`Direct tools available (call as normal tools): ${directSummaries.join(', ')}`)
}
lines.push('')
lines.push('Servers:')
if (servers.length === 0) {
lines.push(' (none assigned)')
} else {
let listedServerCount = 0
for (const s of servers) {
const directCount = s.directToolCount ?? 0
const proxyCount = Math.max(0, s.toolCount - directCount)
if (proxyCount > 0 || directCount === 0) {
lines.push(` - ${s.name} (${proxyCount} tools, status: ${s.status})`)
listedServerCount++
}
}
if (listedServerCount === 0) {
lines.push(' (all assigned tools are configured as direct tools)')
}
}
lines.push('')
lines.push('Usage:')
lines.push(' - mcp({}) → connection/auth status of all servers')
lines.push(' - mcp({ server: "name" }) → list that server\'s tools')
lines.push(' - mcp({ search: "query" }) → search tools across servers')
lines.push(' - mcp({ describe: "tool" }) → show one tool\'s parameter schema')
lines.push(' - mcp({ server: "name", tool: "tool_name", args: {...} }) → call a tool')
lines.push(' - mcp({ instructions: "name" }) → show full server usage instructions')
lines.push(' - mcp({ action: "auth-start", server: "name" }) → start OAuth for a server')
lines.push('')
const instructionLines: string[] = []
for (const s of servers) {
if (!s.instructions || s.instructions.trim() === '') continue
const snippet = truncateInstruction(
s.instructions.replace(/\s+/g, ' ').trim(),
INSTRUCTIONS_SNIPPET_LENGTH,
)
instructionLines.push(` - ${s.name}: ${snippet}`)
}
if (instructionLines.length > 0) {
lines.push('Server instructions (truncated — full text via mcp({ instructions: "name" })):')
lines.push(...instructionLines)
lines.push('')
}
lines.push(
'Tool names are prefixed "{server}_{tool}" (dots replaced by underscores). You may pass either the prefixed or the original name. ' +
'If a call fails with "needs auth", tell the user to connect the server in Settings → MCP.',
)
return lines.join('\n')
}
/**
* Render a server's tool listing with the L2 instructions preview appended
* (mirrors pi-mcp-adapter's mcp({ server }) output). Shared by the `server`
* list mode and the `connect` mode.
*/
function renderServerListing(
serverName: string,
tools: ToolMetadata[],
instructions: string | null,
): string {
const lines = [`${serverName} (${tools.length} tools):`, '']
for (const t of tools) {
lines.push(`- ${t.name}${t.description ? ` - ${t.description.slice(0, 60)}` : ''}`)
}
if (instructions && instructions.trim() !== '') {
const preview = truncateInstruction(instructions, INSTRUCTIONS_PREVIEW_LENGTH)
lines.push('', 'Server instructions:', preview)
if (preview !== instructions) {
lines.push(`Use mcp({ instructions: "${serverName}" }) for the full text.`)
}
}
return lines.join('\n')
}
/**
* Build the single `mcp` proxy AgentTool for a team/session.
*/
export function buildProxyTool(ctx: McpProxyToolContext): AgentTool<typeof proxyToolSchema> {
return {
name: 'mcp',
label: 'MCP Tools',
description: buildProxyDescription(ctx.servers),
parameters: proxyToolSchema,
execute: async (_toolCallId, params): Promise<ProxyToolResult> => {
const action = params.action
const server = params.server
const tool = params.tool
const search = params.search
const describe = params.describe
const instructions = params.instructions
const limit = params.limit ?? 12
const offset = params.offset ?? 0
const includeSchemas = params.includeSchemas !== false
// 1. action: status / auth-start
if (action === 'status') {
const lines: string[] = ['MCP status:']
for (const s of ctx.servers) {
const auth = await ctx.authStatus(s.id)
lines.push(` - ${s.name}: ${s.status} (${s.toolCount} tools, auth: ${auth})`)
}
lines.push('')
lines.push('mcp({ server: "name" }) to list tools, mcp({ search: "..." }) to search')
return contentText(lines.join('\n'))
}
if (action === 'auth-start') {
const serverId = server ? ctx.serverIdByName.get(server) : undefined
if (!serverId) {
return contentText(
`Server "${server ?? ''}" not found. Use mcp({ action: "status" }) to see available servers.`,
)
}
const result = await ctx.startAuth(serverId)
if (result.alreadyAuthenticated) {
return contentText(`OAuth authentication already complete for "${server}".`)
}
if (!result.authorizationUrl) {
return contentText(
`OAuth authentication could not be started for "${server}". Ask an admin to check Settings → MCP.`,
)
}
return contentText(
`OAuth authentication required for "${server}". An admin must open this URL in a browser and approve access:\n\n${result.authorizationUrl}\n\nAfter approving, the browser redirects back to shumai automatically. Then poll mcp({ action: "status", server: "${server}" }) until it shows connected.`,
)
}
// 2. tool call
if (tool) {
const serverId = server ? ctx.serverIdByName.get(server) : undefined
if (server && !serverId) {
return contentText(
`Server "${server}" not found. Use mcp({ action: "status" }) to see available servers.`,
)
}
const resolved = await resolveToolWithLazyConnect(ctx, tool, serverId)
if (!resolved.ok) {
const suggestions = ctx.registry.rankSuggestions(tool, 5, ctx.serverNameById).slice(0, 5)
return notFoundResult(tool, suggestions, server)
}
const outcome = await ctx.callTool(
resolved.serverId,
resolved.tool.originalName,
parseArgs(params.args),
)
if (outcome.ok) {
return { content: outcome.content, details: {} }
}
return {
content: outcome.content,
details: { error: 'tool_call_failed', tool, server: resolved.serverId },
}
}
// 4. describe
if (describe) {
const resolved = ctx.registry.findTool(
describe,
server ? ctx.serverIdByName.get(server) : undefined,
)
if (!resolved) {
const suggestions = ctx.registry
.rankSuggestions(describe, 5, ctx.serverNameById)
.slice(0, 5)
return notFoundResult(describe, suggestions, server)
}
const serverName = ctx.serverNameById.get(resolved.serverId) ?? resolved.serverId
let text = `${resolved.tool.name}\nServer: ${serverName}\n\n${resolved.tool.description || '(no description)'}\n\n`
text += renderToolShape(resolved.tool)
return contentText(text.trim())
}
// 4.5 instructions
if (instructions) {
const serverId = ctx.serverIdByName.get(instructions)
if (!serverId) {
return contentText(
`Server "${instructions}" not found. Use mcp({ action: "status" }) to see available servers.`,
)
}
const text = await ctx.getInstructions(serverId)
if (!text || text.trim() === '') {
return contentText(`Server "${instructions}" does not provide instructions.`)
}
return contentText(`${instructions} instructions:\n\n${text}`)
}
// 5. search
if (search) {
if (search.trim().length === 0 && !server) {
return contentText('Search query cannot be empty')
}
const serverId = server ? ctx.serverIdByName.get(server) : undefined
if (server && !serverId) {
return contentText(
`Server "${server}" not found. Use mcp({ action: "status" }) to see available servers.`,
)
}
const { items, total, hasMore, nextOffset } = ctx.registry.searchTools(
search,
serverId,
ctx.serverNameById,
limit,
offset,
)
if (total === 0) {
return contentText(
`No tools matching "${search}"${server ? ` in "${server}"` : ''}. Use mcp({ action: "status" }) to check connection state.`,
)
}
let text = `Found ${total} tool${total === 1 ? '' : 's'} matching "${search}":\n\n`
for (const match of items) {
const serverName = ctx.serverNameById.get(match.server) ?? match.server
text += `${match.tool.name} (server: ${serverName})\n`
text += ` ${match.tool.description || '(no description)'}\n`
if (includeSchemas && match.tool.inputSchema) {
text += ` ${renderToolShape(match.tool, ' ')}\n`
}
text += '\n'
}
if (hasMore) {
text += `${items.length} of ${total} — offset: ${nextOffset} for more\n`
}
return contentText(text.trim())
}
// 6. server list
if (server) {
const serverId = ctx.serverIdByName.get(server)
if (!serverId) {
return contentText(
`Server "${server}" not found. Use mcp({ action: "status" }) to see available servers.`,
)
}
const tools = ctx.registry.getTools(serverId)
if (tools.length === 0) {
return contentText(
`Server "${server}" has no cached tools yet. Call a tool on this server to connect automatically, or refresh it in Settings → MCP.`,
)
}
const instructionsText = await ctx.getInstructions(serverId)
return contentText(renderServerListing(server, tools, instructionsText))
}
// 7. default: status
const lines: string[] = ['MCP status:']
for (const s of ctx.servers) {
const auth = await ctx.authStatus(s.id)
lines.push(` - ${s.name}: ${s.status} (${s.toolCount} tools, auth: ${auth})`)
}
lines.push('')
lines.push('mcp({ server: "name" }) to list tools, mcp({ search: "..." }) to search')
return contentText(lines.join('\n'))
},
}
}
+443
View File
@@ -0,0 +1,443 @@
/**
* MCP Server Manager
*
* Manages MCP client connections to URL-based servers (Streamable HTTP with
* SSE fallback, or pinned SSE). Simplified port of pi-mcp-adapter's
* server-manager.ts: tools only, no stdio/sampling/elicitation/tracing.
*/
import {
Client,
SdkHttpError,
SSEClientTransport,
StreamableHTTPClientTransport,
UnauthorizedError,
type Implementation,
type ListToolsResult,
type RequestOptions,
type VersionNegotiationOptions,
} from '@modelcontextprotocol/client'
import '@shumai/db/src/prisma-json-types'
import { logger } from '@shumai/core/src/logger'
import type { McpDbStore } from './mcp-db-store'
import { McpOauthProvider, type McpOauthConfig } from './mcp-oauth-provider'
export interface McpTool {
name: string
title?: string
description?: string
inputSchema?: unknown
_meta?: Record<string, unknown>
}
export interface ServerConnection {
client: Client
definition: McpServerDefinition
tools: McpTool[]
status: 'connected' | 'needs-auth'
/** Self-reported server name/title/version/description (from getServerVersion). */
serverVersion?: Implementation
/** Self-reported server usage instructions (from getInstructions). */
instructions?: string
lastUsedAt: number
inFlight: number
}
export interface McpServerDefinition {
name: string
url: string
transport: 'streamable_http' | 'sse'
authConfig?: PrismaJson.McpServerAuthConfig
config?: PrismaJson.McpServerConfig
}
function isUnauthorizedHttpError(error: unknown): boolean {
return (
error instanceof UnauthorizedError || (error instanceof SdkHttpError && error.status === 401)
)
}
function shouldFallbackToSse(error: unknown, definition: McpServerDefinition): boolean {
if (definition.config?.protocolVersion === '2026-07-28') return false
return error instanceof SdkHttpError && [404, 405, 406, 415].includes(error.status)
}
function resolveVersionNegotiation(
definition: McpServerDefinition,
): VersionNegotiationOptions | undefined {
switch (definition.config?.protocolVersion) {
case undefined:
case 'legacy':
return undefined
case 'auto':
return { mode: 'auto' }
case '2026-07-28':
return { mode: { pin: '2026-07-28' } }
default:
throw new Error(`Invalid MCP protocolVersion: ${String(definition.config?.protocolVersion)}`)
}
}
export class McpServerManager {
private connections = new Map<string, ServerConnection>()
private connectPromises = new Map<string, Promise<ServerConnection>>()
private stopped = false
constructor(private readonly dbStore: McpDbStore) {}
private getRequestTimeoutMs(definition: McpServerDefinition): number | undefined {
const timeout = definition.config?.requestTimeoutMs
return typeof timeout === 'number' && Number.isFinite(timeout) && timeout > 0
? timeout
: undefined
}
private buildRequestOptions(definition: McpServerDefinition): RequestOptions | undefined {
const timeout = this.getRequestTimeoutMs(definition)
return timeout !== undefined ? { timeout } : undefined
}
/**
* Connect to a server. Single-flight per server id. Returns a connection
* with status 'connected' or 'needs-auth' (when the server returns 401 and
* OAuth is configured / auto-detectable).
*/
async connect(serverId: string, definition: McpServerDefinition): Promise<ServerConnection> {
if (this.stopped) throw new Error('MCP server manager is closed')
// Dedupe concurrent connection attempts.
if (this.connectPromises.has(serverId)) {
return this.connectPromises.get(serverId)!
}
const existing = this.connections.get(serverId)
if (existing?.status === 'connected') {
existing.lastUsedAt = Date.now()
return existing
}
const promise = this.createConnection(serverId, definition).finally(() => {
if (this.connectPromises.get(serverId) === promise) {
this.connectPromises.delete(serverId)
}
})
this.connectPromises.set(serverId, promise)
try {
const connection = await promise
this.connections.set(serverId, connection)
return connection
} catch (error) {
this.connectPromises.delete(serverId)
throw error
}
}
private async createConnection(
serverId: string,
definition: McpServerDefinition,
): Promise<ServerConnection> {
const url = new URL(definition.url)
const requestInit = this.buildRequestInit(definition)
const authProvider = this.buildAuthProvider(serverId, definition)
const attempt = async (
kind: 'streamable-http' | 'sse',
): Promise<{
status: 'connected' | 'needs-auth'
client: Client
error?: unknown
}> => {
const transportOptions = {
...(requestInit !== undefined ? { requestInit } : {}),
...(authProvider !== undefined ? { authProvider } : {}),
...(authProvider !== undefined &&
definition.authConfig?.oauth?.skipIssuerMetadataValidation === true
? { skipIssuerMetadataValidation: true }
: {}),
}
const transport =
kind === 'streamable-http'
? new StreamableHTTPClientTransport(url, transportOptions)
: new SSEClientTransport(url, transportOptions)
const client = this.createClient(serverId, definition)
try {
await client.connect(transport, this.buildRequestOptions(definition))
return { status: 'connected', client }
} catch (error) {
try {
await client.close()
} catch {
// Ignore cleanup errors on a failed connect.
}
return { status: 'needs-auth', client, error }
}
}
let kind: 'streamable-http' | 'sse' = definition.transport === 'sse' ? 'sse' : 'streamable-http'
for (;;) {
const result = await attempt(kind)
if (result.status === 'connected') {
const tools = await this.fetchAllTools(result.client, this.buildRequestOptions(definition))
return {
client: result.client,
definition,
tools,
status: 'connected',
serverVersion: result.client.getServerVersion(),
instructions: result.client.getInstructions(),
lastUsedAt: Date.now(),
inFlight: 0,
}
}
if (isUnauthorizedHttpError(result.error)) {
if (this.supportsOauth(definition)) {
return {
client: result.client,
definition,
tools: [],
status: 'needs-auth',
lastUsedAt: Date.now(),
inFlight: 0,
}
}
throw result.error
}
if (
kind === 'streamable-http' &&
definition.transport !== 'sse' &&
shouldFallbackToSse(result.error, definition)
) {
kind = 'sse'
continue
}
throw result.error
}
}
private createClient(serverId: string, definition: McpServerDefinition): Client {
const versionNegotiation = resolveVersionNegotiation(definition)
return new Client(
{ name: `shumai-mcp-${serverId}`, version: '1.0.0' },
{
...(versionNegotiation ? { versionNegotiation } : {}),
},
)
}
private buildAuthProvider(
serverId: string,
definition: McpServerDefinition,
): McpOauthProvider | undefined {
if (this.supportsOauth(definition)) {
return new McpOauthProvider(
serverId,
definition.url,
this.extractOauthConfig(definition.authConfig ?? {}),
{ onRedirect: async () => {} },
this.dbStore,
)
}
return undefined
}
private supportsOauth(definition: McpServerDefinition): boolean {
const auth = definition.authConfig
if (auth?.type === 'none') return false
if (auth?.type === 'bearer') return false
// Explicit oauth, or auto-detect when no auth configured and no custom headers.
if (auth?.type === 'oauth') return true
if (auth?.headers && Object.keys(auth.headers).length > 0) return false
return auth === undefined || auth.type === undefined
}
private extractOauthConfig(auth: PrismaJson.McpServerAuthConfig): McpOauthConfig {
const oauth = auth.oauth
if (!oauth) return {}
return {
...(oauth.grantType !== undefined ? { grantType: oauth.grantType } : {}),
...(oauth.clientId !== undefined ? { clientId: oauth.clientId } : {}),
...(oauth.clientSecret !== undefined ? { clientSecret: oauth.clientSecret } : {}),
...(oauth.scope !== undefined ? { scope: oauth.scope } : {}),
...(oauth.authorizationParams !== undefined
? { authorizationParams: oauth.authorizationParams }
: {}),
...(oauth.redirectUri !== undefined ? { redirectUri: oauth.redirectUri } : {}),
...(oauth.clientName !== undefined ? { clientName: oauth.clientName } : {}),
...(oauth.clientUri !== undefined ? { clientUri: oauth.clientUri } : {}),
...(oauth.skipIssuerMetadataValidation !== undefined
? { skipIssuerMetadataValidation: oauth.skipIssuerMetadataValidation }
: {}),
}
}
private buildRequestInit(
definition: McpServerDefinition,
): { headers: Record<string, string> } | undefined {
const auth = definition.authConfig
const headers: Record<string, string> = { ...(auth?.headers ?? {}) }
if (auth?.type === 'bearer' && auth.bearerToken) {
headers['Authorization'] = `Bearer ${auth.bearerToken}`
}
return Object.keys(headers).length > 0 ? { headers } : undefined
}
private async fetchAllTools(client: Client, requestOptions?: RequestOptions): Promise<McpTool[]> {
const allTools: McpTool[] = []
let cursor: string | undefined
do {
const result: ListToolsResult = await client.listTools(
cursor ? { cursor } : undefined,
requestOptions,
)
allTools.push(...(result.tools ?? []))
cursor = result.nextCursor
} while (cursor)
return allTools
}
/** List tools for a connected server. */
async listTools(serverId: string): Promise<McpTool[]> {
const connection = this.connections.get(serverId)
if (!connection || connection.status !== 'connected') {
throw new Error(`Server is not connected`)
}
return connection.tools
}
/** Call a tool on a connected server. */
async callTool(
serverId: string,
toolName: string,
args: Record<string, unknown>,
): Promise<{
content: McpContent[]
structuredContent?: Record<string, unknown>
isError?: boolean
}> {
const connection = this.connections.get(serverId)
if (!connection || connection.status !== 'connected') {
throw new Error(`Server is not connected`)
}
this.incrementInFlight(serverId)
try {
this.touch(serverId)
const result = await connection.client.callTool(
{ name: toolName, arguments: args },
this.buildRequestOptions(connection.definition),
)
return {
content: (result.content ?? []) as McpContent[],
structuredContent: result.structuredContent as Record<string, unknown> | undefined,
isError: result.isError,
}
} finally {
this.decrementInFlight(serverId)
this.touch(serverId)
}
}
incrementInFlight(serverId: string): void {
const connection = this.connections.get(serverId)
if (connection) {
connection.inFlight = (connection.inFlight ?? 0) + 1
}
}
decrementInFlight(serverId: string): void {
const connection = this.connections.get(serverId)
if (connection && connection.inFlight > 0) {
connection.inFlight--
}
}
isIdle(serverId: string, timeoutMs: number): boolean {
const connection = this.connections.get(serverId)
if (!connection || connection.status !== 'connected') return false
if (connection.inFlight > 0) return false
return Date.now() - connection.lastUsedAt > timeoutMs
}
async closeIdleConnections(defaultTimeoutMs = 10 * 60 * 1000): Promise<string[]> {
const closedIds: string[] = []
for (const [serverId, connection] of this.connections) {
if (connection.definition.config?.keepAlive) continue
const timeoutMs = connection.definition.config?.idleTimeoutMs ?? defaultTimeoutMs
if (this.isIdle(serverId, timeoutMs)) {
await this.close(serverId)
closedIds.push(serverId)
}
}
return closedIds
}
touch(serverId: string): void {
const connection = this.connections.get(serverId)
if (connection) {
connection.lastUsedAt = Date.now()
}
}
getConnection(serverId: string): ServerConnection | undefined {
return this.connections.get(serverId)
}
getAllConnections(): Map<string, ServerConnection> {
return new Map(this.connections)
}
async close(serverId: string): Promise<void> {
const connection = this.connections.get(serverId)
if (!connection) {
const pending = this.connectPromises.get(serverId)
if (pending) {
try {
await pending
} catch {
// Ignore failed connect during close.
}
}
return
}
this.connections.delete(serverId)
try {
await connection.client.close()
} catch (error) {
logger.debug({ serverId, error }, 'MCP client close failed')
}
}
async closeAll(): Promise<void> {
const ids = [...this.connections.keys()]
await Promise.allSettled(ids.map((id) => this.close(id)))
this.connections.clear()
this.connectPromises.clear()
// The manager stays usable afterwards (tests reset between suites);
// `stopped` only guards against using a permanently-shut-down manager.
this.stopped = false
}
isConnecting(serverId: string): boolean {
return this.connectPromises.has(serverId)
}
}
export interface McpContent {
type: 'text' | 'image' | 'audio' | 'resource' | 'resource_link'
text?: string
data?: string
mimeType?: string
resource?: {
uri: string
text?: string
blob?: string
}
uri?: string
name?: string
description?: string
}
File diff suppressed because it is too large Load Diff
+965
View File
@@ -0,0 +1,965 @@
/**
* McpService — CRUD, discovery, OAuth, and agent integration for MCP servers.
*/
import { auth } from '@modelcontextprotocol/client'
import type { AgentTool, AgentToolResult } from '@earendil-works/pi-agent-core'
import { prisma } from '@shumai/db'
import '@shumai/db/src/prisma-json-types'
import type {
CreateMcpServerRequest,
McpAuthStatus,
McpServerInfo,
UpdateMcpServerRequest,
} from '@shumai/dtos'
import { logger } from '@shumai/core/src/logger'
import { mcpDbStore, type PendingAuth } from './mcp-db-store'
import { buildDirectTools, isDirectTool } from './mcp-direct-tools'
import { McpOauthProvider, type McpOauthConfig } from './mcp-oauth-provider'
import { buildProxyTool, transformMcpContent, type McpProxyToolContext } from './mcp-proxy-tool'
import {
formatToolName,
McpToolRegistry,
sanitizeServerPrefix,
type ToolMetadata,
} from './mcp-tool-registry'
import { McpServerManager, type McpServerDefinition } from './mcp-server-manager'
const ROLE_HIERARCHY: Record<string, number> = {
owner: 3,
editor: 2,
reviewer: 1,
}
export interface McpToolCallContext {
teamId: string
userId?: string
}
export type McpToolCallContent = AgentToolResult<Record<string, unknown>>['content']
export interface McpToolCallResult {
ok: boolean
content: McpToolCallContent
}
export interface McpServerRecord {
id: string
name: string
description: string | null
instructions: string | null
url: string
transport: 'streamable_http' | 'sse'
authConfig: PrismaJson.McpServerAuthConfig | null
config: PrismaJson.McpServerConfig | null
permission: 'owner' | 'editor' | 'reviewer'
tools: PrismaJson.McpToolInfo[] | null
status: string
lastError: string | null
lastConnectedAt: Date | null
createdAt: Date
updatedAt: Date
teamId: string
credential: { id: string } | null
}
/**
* Derive a placeholder server name from its URL until the server self-reports
* its name/title on first successful connection. Strips www/api/mcp prefixes
* and sanitizes the remaining host label (used as the direct-tool prefix).
*/
function deriveServerName(url: string): string {
try {
const hostname = new URL(url).hostname.toLowerCase()
const labels = hostname.split('.').filter(Boolean)
let label = labels[0] ?? 'mcp-server'
if (labels.length > 1 && ['www', 'api', 'mcp'].includes(label)) {
label = labels[1]
}
const sanitized = label.replace(/[^a-z0-9_-]/g, '_').replace(/^[-_]+|[-_]+$/g, '')
return sanitized || 'mcp-server'
} catch {
return 'mcp-server'
}
}
function generateState(): string {
return Array.from(crypto.getRandomValues(new Uint8Array(32)))
.map((b) => b.toString(16).padStart(2, '0'))
.join('')
}
function extractOauthConfig(authConfig?: PrismaJson.McpServerAuthConfig): McpOauthConfig {
const oauth = authConfig?.oauth
if (!oauth) return {}
return {
...(oauth.grantType !== undefined ? { grantType: oauth.grantType } : {}),
...(oauth.clientId !== undefined ? { clientId: oauth.clientId } : {}),
...(oauth.clientSecret !== undefined ? { clientSecret: oauth.clientSecret } : {}),
...(oauth.scope !== undefined ? { scope: oauth.scope } : {}),
...(oauth.authorizationParams !== undefined
? { authorizationParams: oauth.authorizationParams }
: {}),
...(oauth.redirectUri !== undefined ? { redirectUri: oauth.redirectUri } : {}),
...(oauth.clientName !== undefined ? { clientName: oauth.clientName } : {}),
...(oauth.clientUri !== undefined ? { clientUri: oauth.clientUri } : {}),
...(oauth.skipIssuerMetadataValidation !== undefined
? { skipIssuerMetadataValidation: oauth.skipIssuerMetadataValidation }
: {}),
}
}
export class McpService {
private manager = new McpServerManager(mcpDbStore)
// --------------------------------------------------------------------------
// CRUD
// --------------------------------------------------------------------------
async createServer(teamId: string, req: CreateMcpServerRequest): Promise<McpServerInfo> {
const server = await prisma.mcpServer.create({
data: {
name: deriveServerName(req.url),
url: req.url,
teamId,
transport: req.transport ?? 'streamable_http',
authConfig: (req.authConfig ?? {}) as PrismaJson.McpServerAuthConfig,
config: (req.config ?? {}) as PrismaJson.McpServerConfig,
permission: req.permission ?? 'reviewer',
},
include: { credential: true },
})
return this.toServerInfo(this.mapRecord(server))
}
async updateServer(id: string, req: UpdateMcpServerRequest): Promise<McpServerInfo> {
const existing = await prisma.mcpServer.findUnique({ where: { id } })
if (!existing) throw new Error('MCP server not found')
const authChanged =
req.authConfig !== undefined &&
JSON.stringify(req.authConfig) !== JSON.stringify(existing.authConfig ?? {})
const transportChanged = req.transport !== undefined && req.transport !== existing.transport
// The endpoint URL is immutable (delete + re-add to change it).
// Auth/transport changes invalidate credentials and cached tools.
const invalidateAll = authChanged || transportChanged
await prisma.$transaction(async (tx) => {
if (invalidateAll) {
await tx.mcpServerCredential.deleteMany({ where: { serverId: id } })
}
return tx.mcpServer.update({
where: { id },
data: {
...(req.transport !== undefined ? { transport: req.transport } : {}),
...(req.authConfig !== undefined
? { authConfig: req.authConfig as PrismaJson.McpServerAuthConfig }
: {}),
...(req.config !== undefined ? { config: req.config as PrismaJson.McpServerConfig } : {}),
...(req.permission !== undefined ? { permission: req.permission } : {}),
...(invalidateAll ? { tools: [], status: 'not_connected', lastError: null } : {}),
},
})
})
if (invalidateAll) {
await this.manager.close(id)
}
const record = await this.getServerRecord(id)
if (!record) throw new Error('MCP server not found')
return this.toServerInfo(record)
}
async updateServerPermission(
id: string,
permission: 'owner' | 'editor' | 'reviewer',
): Promise<McpServerInfo> {
const server = await prisma.mcpServer.update({
where: { id },
data: { permission },
include: { credential: true },
})
return this.toServerInfo(this.mapRecord(server))
}
async deleteServer(id: string): Promise<void> {
await this.manager.close(id)
const server = await prisma.mcpServer.findUnique({ where: { id } })
if (!server) return
await prisma.mcpServer.delete({ where: { id } })
}
async listServers(teamId: string): Promise<McpServerInfo[]> {
const servers = await prisma.mcpServer.findMany({
where: { teamId },
orderBy: { id: 'desc' },
include: { credential: true },
})
return servers.map((s) => this.toServerInfo(this.mapRecord(s)))
}
async getServerRecord(id: string): Promise<McpServerRecord | null> {
const server = await prisma.mcpServer.findUnique({
where: { id },
include: { credential: true },
})
if (!server) return null
return this.mapRecord(server)
}
async getServer(id: string): Promise<McpServerInfo | null> {
const server = await this.getServerRecord(id)
if (!server) return null
return this.toServerInfo(server)
}
private mapRecord(server: {
id: string
name: string
description: string | null
instructions: string | null
url: string
transport: 'streamable_http' | 'sse'
authConfig: unknown
config: unknown
permission: 'owner' | 'editor' | 'reviewer'
tools: unknown
status: string
lastError: string | null
lastConnectedAt: Date | null
createdAt: Date
updatedAt: Date
teamId: string
credential: { id: string } | null
}): McpServerRecord {
return {
id: server.id,
name: server.name,
description: server.description,
instructions: server.instructions,
url: server.url,
transport: server.transport,
authConfig: (server.authConfig ?? null) as PrismaJson.McpServerAuthConfig | null,
config: (server.config ?? null) as PrismaJson.McpServerConfig | null,
permission: server.permission,
tools: (server.tools ?? null) as PrismaJson.McpToolInfo[] | null,
status: server.status,
lastError: server.lastError,
lastConnectedAt: server.lastConnectedAt,
createdAt: server.createdAt,
updatedAt: server.updatedAt,
teamId: server.teamId,
credential: server.credential,
}
}
private toServerInfo(server: McpServerRecord): McpServerInfo {
const tools = server.tools ?? []
return {
id: server.id,
name: server.name,
description: server.description ?? undefined,
instructions: server.instructions ?? undefined,
url: server.url,
transport: server.transport,
authType: server.authConfig?.type ?? 'auto',
config: server.config ?? undefined,
permission: server.permission,
status: server.status,
lastError: server.lastError ?? undefined,
toolCount: Array.isArray(tools) ? tools.length : 0,
hasCredential: server.credential !== null,
createdAt: server.createdAt.toISOString(),
updatedAt: server.updatedAt.toISOString(),
}
}
// --------------------------------------------------------------------------
// Discovery
// --------------------------------------------------------------------------
private toDefinition(server: McpServerRecord): McpServerDefinition {
return {
name: server.name,
url: server.url,
transport: server.transport,
authConfig: server.authConfig ?? undefined,
config: server.config ?? undefined,
}
}
private async updateStatus(
serverId: string,
status: string,
lastError: string | null,
extra?: {
tools?: PrismaJson.McpToolInfo[]
lastConnectedAt?: Date
name?: string
description?: string | null
instructions?: string | null
},
): Promise<void> {
await prisma.mcpServer.update({
where: { id: serverId },
data: {
status,
lastError,
...(extra?.tools !== undefined ? { tools: extra.tools } : {}),
...(extra?.lastConnectedAt !== undefined ? { lastConnectedAt: extra.lastConnectedAt } : {}),
...(extra?.name !== undefined ? { name: extra.name } : {}),
...(extra?.description !== undefined ? { description: extra.description } : {}),
...(extra?.instructions !== undefined ? { instructions: extra.instructions } : {}),
},
})
}
private toStoredTools(
tools: Array<{ name: string; title?: string; description?: string; inputSchema?: unknown }>,
): PrismaJson.McpToolInfo[] {
return tools.map((t) => ({
name: t.name,
...(t.title !== undefined ? { title: t.title } : {}),
...(t.description !== undefined ? { description: t.description } : {}),
...(t.inputSchema !== undefined ? { inputSchema: t.inputSchema } : {}),
}))
}
/**
* Persist the server's self-reported metadata (name = title ?? name, plus
* description and instructions) captured after a successful connect.
* Description comes from getServerVersion(); instructions come from
* getInstructions() (a sibling field of the initialize/discover result,
* not part of Implementation).
*/
private serverMetadata(
server: McpServerRecord,
connection: { serverVersion?: unknown; instructions?: string },
): {
name?: string
description?: string | null
instructions?: string | null
} {
const metadata: {
name?: string
description?: string | null
instructions?: string | null
} = {}
const impl = connection.serverVersion as
| { name?: string; title?: string; description?: string }
| undefined
if (impl && typeof impl === 'object') {
const reportedName = impl.title ?? impl.name
if (typeof reportedName === 'string' && reportedName.trim() !== '') {
metadata.name = reportedName.trim()
metadata.description = typeof impl.description === 'string' ? impl.description : null
}
}
if (typeof connection.instructions === 'string') {
metadata.instructions = connection.instructions
} else {
// Sync-on-connect: a server that stops reporting instructions clears
// the cached value (mirrors pi-mcp-adapter's set/delete behavior).
metadata.instructions = null
}
return metadata
}
/**
* Refresh a server: force a fresh connection (closing any existing one),
* then re-discover and persist tools, instructions, name/description and
* status. Returns the updated server record. Throws on connection failure
* (after marking the server as failed). This is the single discovery
* entry point: the refresh endpoint, Test Connection, and post-OAuth
* completion all route through it.
*/
async refreshServer(serverId: string): Promise<McpServerInfo> {
const server = await this.getServerRecord(serverId)
if (!server) throw new Error('MCP server not found')
await this.manager.close(serverId)
try {
const connection = await this.manager.connect(serverId, this.toDefinition(server))
if (connection.status === 'needs-auth') {
await this.updateStatus(serverId, 'needs_auth', null)
} else {
const tools = this.toStoredTools(connection.tools)
const metadata = this.serverMetadata(server, connection)
await this.updateStatus(serverId, 'connected', null, {
tools,
lastConnectedAt: new Date(),
...metadata,
})
}
} catch (error) {
const message = error instanceof Error ? error.message : String(error)
logger.warn({ serverId, error }, 'MCP server refresh failed')
await this.updateStatus(serverId, 'failed', message)
throw error
}
const record = await this.getServerRecord(serverId)
if (!record) throw new Error('MCP server not found')
return this.toServerInfo(record)
}
/** Lazy connect used by the proxy/direct tools; never throws. */
private async ensureConnected(
serverId: string,
registry?: McpToolRegistry,
): Promise<
{ status: 'connected' } | { status: 'needs-auth' } | { status: 'error'; message: string }
> {
const server = await this.getServerRecord(serverId)
if (!server) return { status: 'error', message: 'server not found' }
const existing = this.manager.getConnection(serverId)
if (existing?.status === 'connected') return { status: 'connected' }
try {
const connection = await this.manager.connect(serverId, this.toDefinition(server))
if (connection.status === 'needs-auth') {
await this.updateStatus(serverId, 'needs_auth', null)
return { status: 'needs-auth' }
}
const tools = this.toStoredTools(connection.tools)
const metadata = this.serverMetadata(server, connection)
const displayName = metadata.name ?? server.name
registry?.setTools(serverId, displayName, connection.tools, {
excludeTools: server.config?.excludeTools,
})
await this.updateStatus(serverId, 'connected', null, {
tools,
lastConnectedAt: new Date(),
...metadata,
})
return { status: 'connected' }
} catch (error) {
const message = error instanceof Error ? error.message : String(error)
await this.updateStatus(serverId, 'failed', message)
return { status: 'error', message }
}
}
/**
* Server-reported usage instructions. Prefers the persisted value (the
* cache, so it works without a live connection), falling back to the live
* connection's getInstructions() for a just-connected server.
*/
private async getServerInstructions(serverId: string): Promise<string | null> {
const server = await this.getServerRecord(serverId)
if (!server) return null
if (server.instructions && server.instructions.trim() !== '') return server.instructions
const connection = this.manager.getConnection(serverId)
const live = connection?.client.getInstructions?.()
return typeof live === 'string' && live.trim() !== '' ? live : null
}
// --------------------------------------------------------------------------
// Tool execution
// --------------------------------------------------------------------------
private async checkPermission(
server: McpServerRecord,
ctx?: McpToolCallContext,
): Promise<string | null> {
const requiredLevel = ROLE_HIERARCHY[server.permission] || 1
if (ctx?.userId) {
const member = await prisma.teamMember.findUnique({
where: {
teamIdUserId: {
teamId: server.teamId,
userId: ctx.userId,
},
},
select: { role: true },
})
const userLevel = member ? ROLE_HIERARCHY[member.role] || 0 : 0
if (userLevel < requiredLevel) {
return `Permission denied: Insufficient role to use MCP server "${server.name}". Minimum required role is "${server.permission}".`
}
return null
}
if (requiredLevel > 1) {
return `Permission denied: User context required to use MCP server "${server.name}". Minimum required role is "${server.permission}".`
}
return null
}
private contentFromMcpResult(result: {
content: unknown[]
structuredContent?: Record<string, unknown>
isError?: boolean
}): McpToolCallContent {
const blocks = transformMcpContent(
(Array.isArray(result.content) ? result.content : []) as Parameters<
typeof transformMcpContent
>[0],
)
if (blocks.length > 0) return blocks
if (result.structuredContent !== undefined && result.structuredContent !== null) {
return [
{
type: 'text',
text:
JSON.stringify(result.structuredContent, null, 2) ?? String(result.structuredContent),
},
]
}
return [{ type: 'text', text: '(empty result)' }]
}
/**
* Execute an MCP tool (shared by the proxy and direct tools).
* Permission gate (D10) first; never throws — failures become error text.
*/
async callMcpTool(
serverId: string,
toolName: string,
args: Record<string, unknown>,
ctx?: McpToolCallContext,
): Promise<McpToolCallResult> {
const server = await this.getServerRecord(serverId)
if (!server) {
return { ok: false, content: [{ type: 'text', text: 'MCP server not found' }] }
}
const denied = await this.checkPermission(server, ctx)
if (denied) {
return { ok: false, content: [{ type: 'text', text: denied }] }
}
const outcome = await this.ensureConnected(serverId)
if (outcome.status === 'needs-auth') {
return {
ok: false,
content: [
{
type: 'text',
text: `MCP server "${server.name}" requires authentication. Ask an admin to connect it in Settings → MCP.`,
},
],
}
}
if (outcome.status === 'error') {
return {
ok: false,
content: [
{
type: 'text',
text: `Failed to connect to MCP server "${server.name}": ${outcome.message}`,
},
],
}
}
try {
const result = await this.manager.callTool(serverId, toolName, args)
if (result.isError) {
const text = result.content.map((c) => ('text' in c ? c.text : '[image]')).join('\n')
return {
ok: true,
content: [{ type: 'text', text: text ? `Error: ${text}` : 'Tool execution failed' }],
}
}
return { ok: true, content: this.contentFromMcpResult(result) }
} catch (error) {
const message = error instanceof Error ? error.message : String(error)
await this.updateStatus(serverId, 'failed', message)
return {
ok: false,
content: [
{
type: 'text',
text: `Failed to call tool "${toolName}" on MCP server "${server.name}": ${message}`,
},
],
}
}
}
// --------------------------------------------------------------------------
// OAuth
// --------------------------------------------------------------------------
async startAuth(serverId: string): Promise<{
authorizationUrl?: string
alreadyAuthenticated?: boolean
}> {
const server = await this.getServerRecord(serverId)
if (!server) throw new Error('MCP server not found')
const config = extractOauthConfig(server.authConfig ?? undefined)
if (config.grantType === 'client_credentials') {
const provider = new McpOauthProvider(
serverId,
server.url,
config,
{
onRedirect: async () => {
throw new Error('Browser redirect is not used for client_credentials flow')
},
},
mcpDbStore,
)
try {
const result = await auth(provider, {
serverUrl: server.url,
...(config.scope !== undefined ? { scope: config.scope } : {}),
...(config.skipIssuerMetadataValidation === true
? { skipIssuerMetadataValidation: true }
: {}),
})
if (result !== 'AUTHORIZED') {
throw new Error('Failed to authorize')
}
await mcpDbStore.clearPendingAuth(serverId)
return { alreadyAuthenticated: true }
} finally {
provider.deactivate()
}
}
let capturedUrl: URL | undefined
const provider = new McpOauthProvider(
serverId,
server.url,
config,
{
onRedirect: async (url) => {
capturedUrl = url
},
},
mcpDbStore,
)
try {
const result = await auth(provider, {
serverUrl: server.url,
...(config.scope !== undefined ? { scope: config.scope } : {}),
...(config.skipIssuerMetadataValidation === true
? { skipIssuerMetadataValidation: true }
: {}),
})
if (result === 'AUTHORIZED') {
await mcpDbStore.clearPendingAuth(serverId)
return { alreadyAuthenticated: true }
}
if (!capturedUrl) {
throw new Error('OAuth authorization URL was not provided')
}
const state = (await mcpDbStore.getOauthState(serverId)) ?? generateState()
const discoveryState = await provider.discoveryState()
const pending: PendingAuth = {
state,
authorizationUrl: capturedUrl.toString(),
discovery: (discoveryState ?? {}) as Record<string, unknown>,
expiresAt: Math.floor(Date.now() / 1000) + (await mcpDbStore.getPendingAuthTtlSeconds()),
grantType: 'authorization_code',
...(provider.redirectUrl ? { redirectUri: provider.redirectUrl } : {}),
}
await mcpDbStore.savePendingAuth(serverId, pending)
return { authorizationUrl: capturedUrl.toString() }
} finally {
provider.deactivate()
}
}
/**
* Complete an authorization_code flow. `state` is validated by the caller
* (the API callback route) before delegating here.
*/
async completeAuth(
serverId: string,
input: { code: string; iss?: string },
): Promise<McpAuthStatus> {
const server = await this.getServerRecord(serverId)
if (!server) throw new Error('MCP server not found')
const pending = await mcpDbStore.getPendingAuth(serverId)
if (!pending) throw new Error(`No pending OAuth flow for server: ${server.name}`)
const config = extractOauthConfig(server.authConfig ?? undefined)
const provider = new McpOauthProvider(
serverId,
server.url,
config,
{ onRedirect: async () => {} },
mcpDbStore,
)
try {
const result = await auth(provider, {
serverUrl: server.url,
authorizationCode: input.code,
...(input.iss !== undefined ? { iss: input.iss } : {}),
...(pending.discovery as Record<string, unknown>),
...(config.skipIssuerMetadataValidation === true
? { skipIssuerMetadataValidation: true }
: {}),
})
if (result !== 'AUTHORIZED') {
throw new Error('Failed to authorize')
}
await mcpDbStore.clearPendingAuth(serverId)
await mcpDbStore.clearDiscoverySnapshot(serverId)
try {
await this.refreshServer(serverId)
} catch (err) {
logger.warn(
{ serverId, err },
'Post-auth server refresh failed, setting status to connected',
)
await this.updateStatus(serverId, 'connected', null)
}
return 'authenticated'
} finally {
provider.deactivate()
}
}
/** Find a pending flow by its CSRF state and complete it. */
async handleOauthCallback(
code: string,
state: string,
iss?: string,
): Promise<{ ok: true } | { ok: false; message: string }> {
const rows = await prisma.mcpServerCredential.findMany({
select: { serverId: true, pendingAuth: true },
})
let serverId: string | undefined
for (const row of rows) {
const raw = row.pendingAuth as Partial<PendingAuth> | null
if (raw && typeof raw.state === 'string' && raw.state === state) {
serverId = row.serverId
break
}
}
if (!serverId) {
return { ok: false, message: 'Invalid or expired OAuth state. Start authentication again.' }
}
try {
const status = await this.completeAuth(serverId, { code, iss })
return status === 'authenticated'
? { ok: true }
: { ok: false, message: 'Authentication did not complete' }
} catch (error) {
const message = error instanceof Error ? error.message : String(error)
logger.error({ serverId, error }, 'MCP OAuth callback completion failed')
await mcpDbStore.clearPendingAuth(serverId)
return { ok: false, message }
}
}
async getAuthStatus(serverId: string): Promise<McpAuthStatus> {
const server = await this.getServerRecord(serverId)
if (!server) throw new Error('MCP server not found')
const authType = server.authConfig?.type
if (authType === 'none') return 'authenticated'
if (authType === 'bearer') {
return server.authConfig?.bearerToken ? 'authenticated' : 'not_authenticated'
}
const pending = await mcpDbStore.getPendingAuth(serverId)
if (pending) return 'in_progress'
const hasTokens = await mcpDbStore.hasStoredTokens(serverId)
if (!hasTokens) return 'not_authenticated'
const expired = await mcpDbStore.isTokenExpired(serverId)
return expired ? 'expired' : 'authenticated'
}
async removeAuth(serverId: string): Promise<void> {
await mcpDbStore.clearAllCredentials(serverId)
await mcpDbStore.clearPendingAuth(serverId)
await mcpDbStore.clearDiscoverySnapshot(serverId)
await this.manager.close(serverId)
await this.updateStatus(serverId, 'needs_auth', null)
}
// --------------------------------------------------------------------------
// Agent integration
// --------------------------------------------------------------------------
/**
* Build the agent's MCP AgentTools: the single `mcp` proxy tool plus direct
* tools for assigned servers in direct-tools mode. Returns [] when the agent
* has no assigned servers (no proxy tool — don't waste LLM context).
*/
async buildAgentTools(agentId: string, teamId: string, userId?: string): Promise<AgentTool[]> {
const assignments = await prisma.agentMcpServer.findMany({
where: { agentId },
include: { mcpServer: true },
})
if (assignments.length === 0) return []
// Per-agent tool registry: built fresh for this agent from the persisted
// discovery cache (McpServer.tools). It only ever contains the agent's
// assigned servers, so unassigned/disabled servers can neither be searched
// nor called — no global mutable state to leak through.
const registry = new McpToolRegistry()
const servers = assignments
.map((a) => a.mcpServer)
.map((s) => {
const storedTools = (s.tools ?? []) as PrismaJson.McpToolInfo[]
if (storedTools.length > 0) {
registry.setTools(
s.id,
s.name,
storedTools.map((t) => ({
name: t.name,
description: t.description ?? '',
...(t.inputSchema !== undefined ? { inputSchema: t.inputSchema } : {}),
})),
{ excludeTools: s.config?.excludeTools },
)
}
return {
id: s.id,
name: s.name,
instructions: s.instructions ?? null,
url: s.url,
transport: s.transport,
authConfig: (s.authConfig ?? {}) as PrismaJson.McpServerAuthConfig,
config: (s.config ?? {}) as PrismaJson.McpServerConfig,
status: s.status,
}
})
const serverNameById = new Map<string, string>()
const serverIdByName = new Map<string, string>()
const proxyServers = servers.map((s) => {
serverNameById.set(s.id, s.name)
serverIdByName.set(s.name, s.id)
// Count direct tools from the same filtered registry metadata that
// buildDirectTools consumes, so the proxy description can never drift
// from what is actually registered as native tools.
const metadata = registry.getTools(s.id)
const directToolCount = metadata.filter((t) =>
isDirectTool(t.originalName, t.name, s.config?.directTools),
).length
return {
id: s.id,
name: s.name,
toolCount: metadata.length,
directToolCount,
status: s.status,
...(s.instructions !== null && s.instructions !== undefined
? { instructions: s.instructions }
: {}),
}
})
const ctx: McpProxyToolContext = {
teamId,
userId,
servers: proxyServers,
serverNameById,
serverIdByName,
registry,
resolveServerForTool: (toolName) => {
// Longest {server}_ prefix match (dots/hyphens sanitized like the registry).
let best: string | undefined
let bestLen = 0
for (const [sid, name] of serverNameById.entries()) {
const prefix = sanitizeServerPrefix(name)
if (toolName.startsWith(`${prefix}_`) && prefix.length > bestLen) {
best = sid
bestLen = prefix.length
}
}
return best
},
ensureConnected: (serverId) => this.ensureConnected(serverId, registry),
callTool: (serverId, toolName, args) =>
this.callMcpTool(serverId, toolName, args, { teamId, userId }),
authStatus: (serverId) => this.getAuthStatus(serverId),
startAuth: (serverId) => this.startAuth(serverId),
getInstructions: (serverId) => this.getServerInstructions(serverId),
}
const tools: AgentTool[] = [buildProxyTool(ctx)]
for (const server of servers) {
if (!Array.isArray(server.config?.directTools) || server.config.directTools.length === 0) {
continue
}
const metadata: ToolMetadata[] = registry.getTools(server.id)
tools.push(
...buildDirectTools(metadata, server.config, {
serverId: server.id,
serverName: server.name,
callTool: (serverId, toolName, args) =>
this.callMcpTool(serverId, toolName, args, { teamId, userId }),
}),
)
}
return tools
}
/** Test a server by refreshing it and reporting the tool count (UI validation). */
async testServer(
serverId: string,
): Promise<{ ok: boolean; toolCount: number; message?: string }> {
try {
const server = await this.refreshServer(serverId)
return { ok: true, toolCount: server.toolCount }
} catch (error) {
const message = error instanceof Error ? error.message : String(error)
return { ok: false, toolCount: 0, message }
}
}
/** Tool-name formatter ({server}_{tool}); exposed for tests. */
getToolName(serverName: string, toolName: string): string {
return formatToolName(serverName, toolName)
}
private idleCleanupInterval?: ReturnType<typeof setInterval>
/** Start a periodic background timer to prune idle connections. Default check interval is 30 seconds. */
startIdleCleanupTimer(intervalMs = 30 * 1000, defaultTimeoutMs?: number): void {
if (this.idleCleanupInterval) return
this.idleCleanupInterval = setInterval(() => {
this.closeIdleConnections(defaultTimeoutMs).catch((error) => {
logger.debug({ error }, 'Failed to close idle connections in background timer')
})
}, intervalMs)
this.idleCleanupInterval.unref?.()
}
/** Stop the background idle cleanup timer. */
stopIdleCleanupTimer(): void {
if (this.idleCleanupInterval) {
clearInterval(this.idleCleanupInterval)
this.idleCleanupInterval = undefined
}
}
/** Close all in-process MCP connections (used by tests/shutdown). */
async closeAllConnections(): Promise<void> {
this.stopIdleCleanupTimer()
await this.manager.closeAll()
}
/** Close idle connections across all active server connections. */
async closeIdleConnections(defaultTimeoutMs?: number): Promise<string[]> {
return this.manager.closeIdleConnections(defaultTimeoutMs)
}
/** Number of live in-process connections (used by tests). */
getConnectionCount(serverId: string): number {
return this.manager.getConnection(serverId) ? 1 : 0
}
}
export const mcpService = new McpService()
+163
View File
@@ -0,0 +1,163 @@
/**
* In-process MCP test server for integration tests.
*
* Spins up a real Streamable HTTP MCP server on an ephemeral port using
* `@modelcontextprotocol/server` (v2, stateless mode) and serves it over
* Bun's web-standard fetch. Tests connect to it through the real MCP client
* stack (`@modelcontextprotocol/client` v2), so connection lifecycle, tool
* discovery, argument validation, and call round-trips are all exercised for
* real — no mocks.
*/
import { McpServer, WebStandardStreamableHTTPServerTransport } from '@modelcontextprotocol/server'
import { z, type ZodRawShape } from 'zod'
export interface TestMcpToolDef {
name: string
description?: string
inputSchema?: ZodRawShape
handler: (args: Record<string, unknown>) => Promise<unknown>
/** When set, the tool returns an isError result with this text. */
errorText?: string
}
export interface TestMcpServerOptions {
tools: TestMcpToolDef[]
/** If set, respond with 401 to any request that lacks this bearer token. */
bearerToken?: string
/** Port to bind; defaults to an ephemeral port. */
port?: number
/** Override the server's self-reported identity (getServerVersion result). */
serverInfo?: { name: string; title?: string; description?: string; instructions?: string }
}
export interface RunningTestMcpServer {
url: string
port: number
stop(): Promise<void>
/** Requests received, in order, with their headers. */
requests: Array<{ url: string; headers: Record<string, string> }>
}
export async function startTestMcpServer(
options: TestMcpServerOptions,
): Promise<RunningTestMcpServer> {
const { serverInfo } = options
const server = new McpServer(
{
name: serverInfo?.name ?? 'test-mcp-server',
version: '1.0.0',
...(serverInfo?.title !== undefined ? { title: serverInfo.title } : {}),
...(serverInfo?.description !== undefined ? { description: serverInfo.description } : {}),
},
serverInfo?.instructions !== undefined ? { instructions: serverInfo.instructions } : undefined,
)
// registerTool has overloads with incompatible zod type resolutions; bind a
// narrow local signature so tool registration stays type-safe and simple.
const registerTool = server.registerTool.bind(server) as unknown as (
name: string,
config: { description?: string; inputSchema?: ZodRawShape },
cb: (args: Record<string, unknown>) => Promise<unknown> | unknown,
) => unknown
for (const tool of options.tools) {
registerTool(
tool.name,
{
description: tool.description ?? `Test tool ${tool.name}`,
inputSchema: tool.inputSchema ?? {},
},
async (args) => {
if (tool.errorText) {
return {
content: [{ type: 'text', text: tool.errorText }],
isError: true,
}
}
const result = await tool.handler(args as Record<string, unknown>)
if (typeof result === 'string') {
return { content: [{ type: 'text', text: result }] }
}
if (
result &&
typeof result === 'object' &&
'structuredContent' in (result as Record<string, unknown>)
) {
const structuredContent = (result as Record<string, unknown>).structuredContent
return {
content: [{ type: 'text', text: JSON.stringify(structuredContent) }],
structuredContent,
}
}
return { content: [{ type: 'text', text: JSON.stringify(result) }] }
},
)
}
// Stateless mode: one transport instance, no session IDs.
const transport = new WebStandardStreamableHTTPServerTransport({
sessionIdGenerator: undefined,
})
await server.connect(transport)
const requests: RunningTestMcpServer['requests'] = []
const httpServer = Bun.serve({
port: options.port ?? 0,
idleTimeout: 30,
async fetch(req) {
requests.push({
url: req.url,
headers: Object.fromEntries(req.headers.entries()),
})
if (options.bearerToken) {
const auth = req.headers.get('authorization')
if (auth !== `Bearer ${options.bearerToken}`) {
return new Response('Unauthorized', { status: 401 })
}
}
const url = new URL(req.url)
if (url.pathname === '/mcp') {
return transport.handleRequest(req)
}
return new Response('not found', { status: 404 })
},
})
const port = httpServer.port as number
return {
url: `http://localhost:${port}/mcp`,
port,
requests,
async stop() {
await server.close().catch(() => {})
httpServer.stop(true)
},
}
}
/** Common test tools: echo (returns string), add (structured math), list_sims. */
export function standardTestTools(): TestMcpToolDef[] {
return [
{
name: 'echo',
description: 'Echoes the provided text back',
inputSchema: { text: z.string() },
handler: async (args) => `echo:${String(args.text)}`,
},
{
name: 'add',
description: 'Adds two numbers',
inputSchema: { a: z.number(), b: z.number() },
handler: async (args) => ({
structuredContent: { sum: Number(args.a) + Number(args.b) },
}),
},
{
name: 'list_sims',
description: 'Lists simulator devices',
handler: async () => ['iPhone 15 Pro', 'iPad Pro'],
},
]
}
@@ -0,0 +1,182 @@
import { describe, it, expect } from 'vitest'
import {
McpToolRegistry,
formatToolName,
normalizeSearchText,
sanitizeServerPrefix,
tokenize,
scoreToolMatch,
paginate,
} from './mcp-tool-registry'
function makeRegistry() {
const registry = new McpToolRegistry()
registry.setTools('server-1', 'xcodebuild', [
{ name: 'list_sims', description: 'Lists available simulator devices' },
{ name: 'build', description: 'Builds an Xcode project' },
{ name: 'showBuildSettings', description: 'Shows build settings for a target' },
])
registry.setTools('server-2', 'github', [
{ name: 'create_issue', description: 'Creates a GitHub issue' },
{ name: 'list_issues', description: 'Lists issues in a repository' },
{ name: 'search_code', description: 'Searches code across repositories' },
])
return registry
}
describe('formatToolName', () => {
it('prefixes server name and sanitizes dots', () => {
expect(formatToolName('xcodebuild', 'list_sims')).toBe('xcodebuild_list_sims')
expect(formatToolName('my-server', 'tool.name')).toBe('my_server_tool_name')
})
it('sanitizes spaces and punctuation in the server prefix', () => {
expect(formatToolName('Meta Server', 'echo')).toBe('Meta_Server_echo')
expect(formatToolName('my.server/v1', 'list')).toBe('my_server_v1_list')
expect(formatToolName('!!!', 'list')).toBe('list')
})
})
describe('sanitizeServerPrefix', () => {
it('collapses non-alphanumeric runs into a single underscore', () => {
expect(sanitizeServerPrefix('Meta Server')).toBe('Meta_Server')
expect(sanitizeServerPrefix('github.com')).toBe('github_com')
expect(sanitizeServerPrefix(' a b ')).toBe('a_b')
})
})
describe('normalizeSearchText / tokenize', () => {
it('splits camelCase, snake_case, dots and hyphens', () => {
expect(tokenize('showBuildSettings')).toEqual(['show', 'build', 'settings'])
expect(tokenize('list_sims')).toEqual(['list', 'sims'])
expect(tokenize('search.code-v2')).toEqual(['search', 'code', 'v2'])
})
it('lowercases input', () => {
expect(normalizeSearchText('ListSims')).toBe('list sims')
})
})
describe('scoreToolMatch', () => {
const tool = {
name: 'xcodebuild_list_sims',
originalName: 'list_sims',
description: 'Lists available simulator devices',
}
it('returns null for empty queries', () => {
expect(scoreToolMatch(tool, 'xcodebuild', '')).toBeNull()
expect(scoreToolMatch(tool, 'xcodebuild', ' ')).toBeNull()
})
it('scores exact name matches highest', () => {
const exact = scoreToolMatch(tool, 'xcodebuild', 'list_sims')
const partial = scoreToolMatch(tool, 'xcodebuild', 'sims')
const unrelated = scoreToolMatch(tool, 'xcodebuild', 'zzz')
expect(exact).not.toBeNull()
expect(partial).not.toBeNull()
expect(unrelated).toBeNull()
expect(exact!).toBeGreaterThan(partial!)
})
it('matches camelCase queries against camelCase original names', () => {
const camel = scoreToolMatch(
{
name: 'xcodebuild_showBuildSettings',
originalName: 'showBuildSettings',
description: 'Shows build settings',
},
'xcodebuild',
'showBuildSettings',
)
expect(camel).not.toBeNull()
})
})
describe('registry searchTools', () => {
it('finds tools across servers with ranking', () => {
const registry = makeRegistry()
const names = new Map([
['server-1', 'xcodebuild'],
['server-2', 'github'],
])
const { items, total } = registry.searchTools('list', undefined, names)
expect(total).toBeGreaterThanOrEqual(2)
// Both list_sims and list_issues should be found.
const found = items.map((m) => m.tool.originalName)
expect(found).toContain('list_sims')
expect(found).toContain('list_issues')
// Sorting is by score descending.
for (let i = 1; i < items.length; i++) {
expect(items[i - 1].score).toBeGreaterThanOrEqual(items[i].score)
}
})
it('scopes search to one server', () => {
const registry = makeRegistry()
const names = new Map([
['server-1', 'xcodebuild'],
['server-2', 'github'],
])
const { items, total } = registry.searchTools('list', 'server-1', names)
expect(total).toBe(1)
expect(items[0].tool.originalName).toBe('list_sims')
})
it('honors limit/offset pagination', () => {
const registry = makeRegistry()
const names = new Map([
['server-1', 'xcodebuild'],
['server-2', 'github'],
])
const first = registry.searchTools('list', undefined, names, 1, 0)
expect(first.items.length).toBe(1)
expect(first.hasMore).toBe(true)
const second = registry.searchTools('list', undefined, names, 1, 1)
expect(second.items.length).toBe(1)
expect(second.nextOffset).toBeNull()
})
it('coverage gate rejects weak matches', () => {
const registry = makeRegistry()
const names = new Map([['server-1', 'xcodebuild']])
const { total } = registry.searchTools('building skyscrapers', 'server-1', names)
expect(total).toBe(0)
})
})
describe('registry findTool', () => {
it('finds by prefixed or original name', () => {
const registry = makeRegistry()
expect(registry.findTool('xcodebuild_list_sims')?.tool.originalName).toBe('list_sims')
expect(registry.findTool('list_sims')?.tool.originalName).toBe('list_sims')
expect(registry.findTool('list_sims', 'server-1')?.tool.originalName).toBe('list_sims')
expect(registry.findTool('list_sims', 'server-2')).toBeUndefined()
expect(registry.findTool('nope')).toBeUndefined()
})
it('returns did-you-mean suggestions', () => {
const registry = makeRegistry()
const suggestions = registry.rankSuggestions(
'xcodebuild_list_sim',
5,
new Map([
['server-1', 'xcodebuild'],
['server-2', 'github'],
]),
)
expect(suggestions).toContain('xcodebuild_list_sims')
})
})
describe('paginate', () => {
it('handles empty input and offsets beyond length', () => {
expect(paginate([], 0, 10)).toEqual({ items: [], total: 0, hasMore: false, nextOffset: null })
expect(paginate([1, 2, 3], 100, 10)).toEqual({
items: [],
total: 3,
hasMore: false,
nextOffset: null,
})
})
})
+275
View File
@@ -0,0 +1,275 @@
/**
* MCP tool registry — in-memory tool metadata + search
*
* Per-agent registry of discovered tool metadata keyed by server id, created
* fresh by `McpService.buildAgentTools` and warmed from the persisted DB
* cache (`McpServer.tools`). Scoping discovery to the agent's assigned
* servers means unassigned/disabled servers can never be searched, suggested,
* or called. (Adapted from pi-mcp-adapter's ToolMetadata + search-ranking.ts.)
*/
import type { McpTool } from './mcp-server-manager'
export interface ToolMetadata {
/** Prefixed tool name (e.g. "xcodebuild_list_sims"). */
name: string
/** Original MCP tool name (e.g. "list_sims"). */
originalName: string
description: string
inputSchema?: unknown
}
/**
* Sanitize a server name into a safe tool-name prefix: any run of
* non-alphanumeric characters becomes a single underscore. Server-reported
* names/titles may contain spaces, dots or other punctuation.
*/
export function sanitizeServerPrefix(serverName: string): string {
return serverName.replace(/[^a-zA-Z0-9_]+/g, '_').replace(/^_+|_+$/g, '')
}
/** Format a tool name with the "{server}_{tool}" prefix (dots sanitized). */
export function formatToolName(serverName: string, toolName: string): string {
const serverPart = sanitizeServerPrefix(serverName)
const sanitized = toolName.replace(/\./g, '_')
return serverPart ? `${serverPart}_${sanitized}` : sanitized
}
function globToRegExp(pattern: string): RegExp {
const escaped = pattern
.replace(/[.+^${}()|[\]\\]/g, '\\$&')
.replace(/\*/g, '.*')
.replace(/\?/g, '.')
return new RegExp(`^${escaped}$`)
}
function matchesToolPattern(name: string, patterns?: string[]): boolean {
if (!Array.isArray(patterns) || patterns.length === 0) return false
for (const pattern of patterns) {
if (!pattern) continue
if (!pattern.includes('*') && !pattern.includes('?') && name === pattern) return true
if ((pattern.includes('*') || pattern.includes('?')) && globToRegExp(pattern).test(name)) {
return true
}
}
return false
}
/**
* Decide whether a tool is allowed by excludeTools (matches prefixed or
* original name). Applied when building the per-agent registry so excluded
* tools are invisible to both the proxy tool and direct registration.
*/
export function isToolAllowed(
prefixedName: string,
originalName: string,
excludeTools?: string[],
): boolean {
if (
matchesToolPattern(prefixedName, excludeTools) ||
matchesToolPattern(originalName, excludeTools)
) {
return false
}
return true
}
const MIN_STEM_LENGTH = 4
const FIELD_WEIGHTS = {
name: 12,
originalName: 10,
server: 8,
description: 5,
} as const
export interface RankedToolMatch {
server: string
tool: ToolMetadata
score: number
}
export function normalizeSearchText(value: string): string {
return value
.replace(/([a-z0-9])([A-Z])/g, '$1 $2')
.replace(/[_./:-]+/g, ' ')
.toLowerCase()
}
export function tokenize(value: string): string[] {
return normalizeSearchText(value)
.split(/[^a-z0-9]+/)
.filter(Boolean)
}
export function scoreToolMatch(tool: ToolMetadata, server: string, query: string): number | null {
const normalizedQuery = normalizeSearchText(query).trim()
const queryTokens = tokenize(query)
if (queryTokens.length === 0) return null
const fields = {
name: normalizeSearchText(tool.name),
originalName: normalizeSearchText(tool.originalName),
server: normalizeSearchText(server),
description: normalizeSearchText(tool.description),
}
let score = 0
let phraseMatched = false
let wholeFieldExact = false
const matchedTokens = new Set<string>()
for (const [field, value] of Object.entries(fields) as Array<
[keyof typeof FIELD_WEIGHTS, string]
>) {
const weight = FIELD_WEIGHTS[field]
const fieldTokens = tokenize(value)
if (value === normalizedQuery) {
score += weight * 14
phraseMatched = true
wholeFieldExact = true
} else if (value.startsWith(normalizedQuery)) {
score += weight * 9
phraseMatched = true
} else if (value.includes(normalizedQuery)) {
score += weight * 6
phraseMatched = true
}
for (const token of queryTokens) {
if (fieldTokens.includes(token)) {
score += weight * 4
matchedTokens.add(token)
} else if (
fieldTokens.some(
(fieldToken) =>
fieldToken.startsWith(token) ||
(fieldToken.length >= MIN_STEM_LENGTH && token.startsWith(fieldToken)),
)
) {
score += weight * 2
matchedTokens.add(token)
} else if (value.includes(token)) {
score += weight
matchedTokens.add(token)
}
}
}
const coverage = matchedTokens.size / queryTokens.length
if (!phraseMatched && (queryTokens.length <= 2 ? coverage !== 1 : coverage < 0.6)) return null
score += coverage === 1 ? 25 : Math.round(coverage * 10)
const firstQueryToken = queryTokens[0]
if (firstQueryToken !== undefined && tokenize(fields.name).includes(firstQueryToken)) score += 8
if (wholeFieldExact) score += 20
return score
}
export function paginate<T>(
items: T[],
offset: number,
limit: number,
): { items: T[]; total: number; hasMore: boolean; nextOffset: number | null } {
const safeOffset = Number.isFinite(offset) ? Math.max(0, Math.trunc(offset)) : 0
const safeLimit = Number.isFinite(limit) ? Math.max(1, Math.trunc(limit)) : 1
const total = items.length
const page = items.slice(safeOffset, safeOffset + safeLimit)
const nextOffset = safeOffset + page.length
return {
items: page,
total,
hasMore: nextOffset < total,
nextOffset: nextOffset < total ? nextOffset : null,
}
}
export class McpToolRegistry {
private readonly metadataByServer = new Map<string, ToolMetadata[]>()
/**
* Rebuild the metadata for one server from its discovered tools, skipping
* tools excluded via excludeTools so they are unreachable through the proxy.
*/
setTools(
serverId: string,
serverName: string,
tools: McpTool[],
opts?: { excludeTools?: string[] },
): void {
const metadata: ToolMetadata[] = []
for (const tool of tools) {
const name = formatToolName(serverName, tool.name)
if (!isToolAllowed(name, tool.name, opts?.excludeTools)) continue
metadata.push({
name,
originalName: tool.name,
description: tool.description ?? '',
...(tool.inputSchema !== undefined ? { inputSchema: tool.inputSchema } : {}),
})
}
metadata.sort((a, b) => a.name.localeCompare(b.name))
this.metadataByServer.set(serverId, metadata)
}
getTools(serverId: string): ToolMetadata[] {
return this.metadataByServer.get(serverId) ?? []
}
getAllTools(): Array<{ serverId: string; serverName: string; tool: ToolMetadata }> {
const result: Array<{ serverId: string; serverName: string; tool: ToolMetadata }> = []
for (const [serverId, metadata] of this.metadataByServer.entries()) {
for (const tool of metadata) {
result.push({ serverId, serverName: serverId, tool })
}
}
return result
}
clear(serverId: string): void {
this.metadataByServer.delete(serverId)
}
clearAll(): void {
this.metadataByServer.clear()
}
/** Find a tool by prefixed or original name, optionally within one server. */
findTool(name: string, serverId?: string): { serverId: string; tool: ToolMetadata } | undefined {
for (const [sid, metadata] of this.metadataByServer.entries()) {
if (serverId && sid !== serverId) continue
const found = metadata.find((tool) => tool.name === name || tool.originalName === name)
if (found) return { serverId: sid, tool: found }
}
return undefined
}
/** Ranked search across all (or one) server's tools. */
searchTools(
query: string,
serverId?: string,
serverNames: Map<string, string> = new Map(),
limit = 12,
offset = 0,
): { items: RankedToolMatch[]; total: number; hasMore: boolean; nextOffset: number | null } {
const matches: RankedToolMatch[] = []
for (const [sid, metadata] of this.metadataByServer.entries()) {
if (serverId && sid !== serverId) continue
const serverName = serverNames.get(sid) ?? sid
for (const tool of metadata) {
const score = scoreToolMatch(tool, serverName, query)
if (score !== null) matches.push({ server: sid, tool, score })
}
}
matches.sort((a, b) => b.score - a.score || a.tool.name.localeCompare(b.tool.name))
return paginate(matches, offset, limit)
}
/** "Did you mean" suggestions for a tool name. */
rankSuggestions(
name: string,
limit: number,
serverNames: Map<string, string> = new Map(),
): string[] {
return this.searchTools(name, undefined, serverNames, limit, 0).items.map((m) => m.tool.name)
}
}
@@ -0,0 +1,99 @@
import { describe, it, expect } from 'vitest'
import { toToolParameters, formatSchema } from './mcp-tool-schema'
import { Compile } from 'typebox/compile'
describe('toToolParameters', () => {
it('passes through a plain object schema', () => {
const schema = {
type: 'object',
properties: { query: { type: 'string' } },
required: ['query'],
}
const params = toToolParameters(schema)
expect(params).toMatchObject({ type: 'object', properties: { query: { type: 'string' } } })
// The resulting schema must compile with the same validator pi-ai uses.
expect(() => Compile(params)).not.toThrow()
})
it('strips $schema / $id / $comment keywords', () => {
const params = toToolParameters({
$schema: 'http://json-schema.org/draft-07/schema#',
$id: 'https://example.com/tool.json',
$comment: 'strip me',
type: 'object',
properties: { a: { type: 'string' } },
})
expect(JSON.stringify(params)).not.toContain('$schema')
expect(JSON.stringify(params)).not.toContain('$id')
expect(JSON.stringify(params)).not.toContain('$comment')
})
it('supports $defs / $ref schemas', () => {
const params = toToolParameters({
type: 'object',
properties: { q: { $ref: '#/$defs/query' } },
$defs: { query: { type: 'string' } },
required: ['q'],
})
const compiled = Compile(params)
expect(compiled.Check({ q: 'hello' })).toBe(true)
})
it('supports anyOf and enums', () => {
const params = toToolParameters({
type: 'object',
properties: {
value: { anyOf: [{ type: 'string' }, { type: 'number' }] },
color: { type: 'string', enum: ['red', 'blue'] },
},
})
const compiled = Compile(params)
expect(compiled.Check({ value: 42, color: 'red' })).toBe(true)
expect(compiled.Check({ value: 'x', color: 'green' })).toBe(false)
})
it('supports additionalProperties and patternProperties', () => {
const params = toToolParameters({
type: 'object',
properties: { a: { type: 'string' } },
additionalProperties: false,
})
const compiled = Compile(params)
expect(compiled.Check({ a: 'x' })).toBe(true)
const patterned = toToolParameters({
type: 'object',
patternProperties: { '^x-': { type: 'string' } },
})
expect(() => Compile(patterned)).not.toThrow()
})
it('normalizes non-object roots to an object', () => {
expect(toToolParameters({ type: 'string' })).toMatchObject({ type: 'object' })
})
it('falls back to a permissive record for invalid schemas', () => {
const params = toToolParameters({ type: 'object', properties: { bad: { type: 'not-a-type' } } })
const compiled = Compile(params)
// Fallback must accept arbitrary arguments.
expect(compiled.Check({ anything: 123, nested: { x: 1 } })).toBe(true)
})
it('handles undefined / empty input', () => {
expect(toToolParameters(undefined)).toMatchObject({ type: 'object' })
expect(toToolParameters(null)).toMatchObject({ type: 'object' })
})
})
describe('formatSchema', () => {
it('formats JSON Schema as indented text', () => {
const text = formatSchema({ type: 'object', properties: { a: { type: 'string' } } })
expect(text).toContain('"type": "object"')
expect(text).toContain('"properties"')
})
it('returns empty string for non-objects', () => {
expect(formatSchema(undefined)).toBe('')
expect(formatSchema(42)).toBe('')
})
})
+62
View File
@@ -0,0 +1,62 @@
/**
* MCP tool schema conversion
*
* Normalizes an MCP tool's JSON Schema `inputSchema` into a TypeBox-compatible
* `TSchema` that the pi-ai harness can validate and providers can serialize.
*
* - Ensures `type: 'object'` (MCP tool arguments are always objects).
* - Strips keywords the harness does not understand (`$schema`, `$id`, `$comment`).
* - Verifies the schema compiles with `typebox/compile`; if it does not, falls
* back to a permissive `Record<string, unknown>` so the tool still works
* (arguments pass through to `callTool`).
*/
import { Compile } from 'typebox/compile'
import { Type, type TSchema } from '@sinclair/typebox'
const STRIPPED_KEYS = new Set(['$schema', '$id', '$comment'])
function normalizeInputSchema(schema: unknown): Record<string, unknown> {
if (!schema || typeof schema !== 'object' || Array.isArray(schema)) {
return { type: 'object' }
}
const source = schema as Record<string, unknown>
const result: Record<string, unknown> = {}
for (const [key, value] of Object.entries(source)) {
if (STRIPPED_KEYS.has(key)) continue
if (value === undefined) continue
result[key] = value
}
// MCP tool parameters are always a JSON object.
if (result.type !== 'object' && result.type !== undefined) {
result.type = 'object'
}
return result
}
/**
* Convert an MCP `inputSchema` into an AgentTool `parameters` schema.
*/
export function toToolParameters(inputSchema: unknown): TSchema {
const normalized = normalizeInputSchema(inputSchema)
try {
Compile(normalized)
return normalized as TSchema
} catch {
// Fall back to a permissive object schema so the tool remains usable.
return Type.Record(Type.String(), Type.Unknown())
}
}
/** Format a JSON Schema as indented text (used by proxy describe/search). */
export function formatSchema(schema: unknown, indent = ''): string {
if (!schema || typeof schema !== 'object') return ''
try {
return JSON.stringify(schema, null, 2)
.split('\n')
.map((line) => `${indent}${line}`)
.join('\n')
} catch {
return String(schema)
}
}
+81 -1
View File
@@ -1,7 +1,7 @@
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
import * as fs from 'fs'
import * as path from 'path'
import { LocalStorageService, S3StorageService } from './s3'
import { buildContentDisposition, LocalStorageService, S3StorageService } from './s3'
// Mock Bun S3Client
const s3ClientConstructorSpy = vi.fn()
@@ -140,6 +140,32 @@ describe('S3Service implementations', () => {
)
})
it('should set contentDisposition with the filename when download filename is provided', async () => {
const s3 = new S3StorageService('http://localhost:9000', 'key', 'secret', 'test-bucket')
await s3.presign('bucket', 'key', 'GET', true, 'foo.png')
expect(s3PresignSpy).toHaveBeenCalledWith(
'key',
expect.objectContaining({
contentDisposition: 'attachment; filename="foo.png"; filename*=UTF-8\'\'foo.png',
}),
)
})
it('should include an RFC 5987 filename* for non-ASCII filenames', async () => {
const s3 = new S3StorageService('http://localhost:9000', 'key', 'secret', 'test-bucket')
await s3.presign('bucket', 'key', 'GET', true, '报告.png')
expect(s3PresignSpy).toHaveBeenCalledWith(
'key',
expect.objectContaining({
// Non-ASCII names are conveyed only via filename* (percent-encoded),
// keeping the header value pure ASCII (RFC 7230).
contentDisposition: "attachment; filename*=UTF-8''%E6%8A%A5%E5%91%8A.png",
}),
)
})
it('should not cache download presign URLs', async () => {
const s3 = new S3StorageService('http://localhost:9000', 'key', 'secret', 'test-bucket')
@@ -248,6 +274,18 @@ describe('S3Service implementations', () => {
expect(url).toBe('http://localhost:3000/files/my-bucket/dir/file.txt?download=1')
})
it('should include an encoded filename in the local download URL', async () => {
const url = await localS3.presign('my-bucket', 'dir/file.txt', 'GET', true, 'foo bar.png')
expect(url).toBe(
'http://localhost:3000/files/my-bucket/dir/file.txt?download=1&filename=foo%20bar.png',
)
})
it('should not append a filename param when none is provided', async () => {
const url = await localS3.presign('my-bucket', 'dir/file.txt', 'GET', true)
expect(url).not.toContain('filename=')
})
it('should throw an error for unsupported presign methods', async () => {
await expect(localS3.presign('b', 'k', 'POST')).rejects.toThrow()
})
@@ -287,4 +325,46 @@ describe('S3Service implementations', () => {
expect(url).not.toContain('4567')
})
})
describe('buildContentDisposition', () => {
it('returns plain attachment when no filename is provided', () => {
expect(buildContentDisposition()).toBe('attachment')
expect(buildContentDisposition('')).toBe('attachment')
expect(buildContentDisposition(null)).toBe('attachment')
})
it('builds a disposition with quoted filename and RFC 5987 filename*', () => {
expect(buildContentDisposition('foo.png')).toBe(
'attachment; filename="foo.png"; filename*=UTF-8\'\'foo.png',
)
})
it('strips control characters and quotes to prevent header injection', () => {
expect(buildContentDisposition('a\r\nb"c\\d')).toBe(
'attachment; filename="abcd"; filename*=UTF-8\'\'abcd',
)
})
it('percent-encodes reserved RFC 5987 characters', () => {
expect(buildContentDisposition("it's (final).png")).toBe(
"attachment; filename=\"it's (final).png\"; filename*=UTF-8''it%27s%20%28final%29.png",
)
})
it('percent-encodes the * character in filename*', () => {
expect(buildContentDisposition('foo*bar.png')).toBe(
'attachment; filename="foo*bar.png"; filename*=UTF-8\'\'foo%2Abar.png',
)
})
it('omits the quoted filename fallback for non-ASCII names to keep the header ASCII', () => {
expect(buildContentDisposition('幻境边界.pptx')).toBe(
"attachment; filename*=UTF-8''%E5%B9%BB%E5%A2%83%E8%BE%B9%E7%95%8C.pptx",
)
// The whole header value must remain pure ASCII so Bun/Node Headers accept it
expect(
[...buildContentDisposition('幻境边界.pptx')].every((ch) => ch.charCodeAt(0) <= 0x7f),
).toBe(true)
})
})
})
+57 -4
View File
@@ -27,6 +27,38 @@ export function verifyLocalUrlSignature(bucket: string, key: string, signature:
}
}
/**
* Build a Content-Disposition header value for downloads.
* - Falls back to plain `attachment` when no filename is provided.
* - Strips control characters (CR/LF header injection), quotes, and backslashes.
* - Header values must be ASCII (RFC 7230): non-ASCII names are conveyed only
* via the percent-encoded RFC 5987 `filename*` parameter; the quoted
* `filename="..."` fallback is included only when the name is pure ASCII.
*/
export function buildContentDisposition(filename?: string | null): string {
if (!filename) return 'attachment'
// Strip C0 control characters (incl. CR/LF header injection) and DEL, then
// quotes/backslashes which would break the quoted-string form.
const sanitized = [...filename]
.filter((ch) => {
const code = ch.charCodeAt(0)
return code > 0x1f && code !== 0x7f && ch !== '"' && ch !== '\\'
})
.join('')
.trim()
if (!sanitized) return 'attachment'
// RFC 5987 attr-char excludes ' ( ) * — percent-encode them explicitly
const encoded = encodeURIComponent(sanitized).replace(
/['()*]/g,
(c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`,
)
const isAscii = [...sanitized].every((ch) => ch.charCodeAt(0) <= 0x7f)
if (!isAscii) {
return `attachment; filename*=UTF-8''${encoded}`
}
return `attachment; filename="${sanitized}"; filename*=UTF-8''${encoded}`
}
export interface S3Object {
buffer: Buffer
contentType: string
@@ -55,7 +87,13 @@ export interface S3Service {
listObjects: (bucket: string, prefix: string) => Promise<string[]>
uploadFile: (filePath: string, contentType: string) => Promise<string>
uploadFileToKey: (filePath: string, key: string, contentType: string) => Promise<void>
presign: (bucket: string, key: string, method: string, download?: boolean) => Promise<string>
presign: (
bucket: string,
key: string,
method: string,
download?: boolean,
filename?: string,
) => Promise<string>
}
export class S3StorageService implements S3Service {
@@ -214,7 +252,13 @@ export class S3StorageService implements S3Service {
})
}
async presign(bucket: string, key: string, method: string, download?: boolean): Promise<string> {
async presign(
bucket: string,
key: string,
method: string,
download?: boolean,
filename?: string,
): Promise<string> {
const expireHours = parseInt(process.env.PRESIGNED_URL_EXPIRES_IN || '5', 10)
const expiresInSeconds = expireHours * 3600
// Cache time is 2/3 of expire time, rounded to minute
@@ -237,7 +281,7 @@ export class S3StorageService implements S3Service {
}
if (download) {
options.contentDisposition = 'attachment'
options.contentDisposition = buildContentDisposition(filename)
}
const url = this.client.presign(key, options)
@@ -461,7 +505,13 @@ export class LocalStorageService implements S3Service {
await fs.promises.copyFile(filePath, destPath)
}
async presign(bucket: string, key: string, method: string, download?: boolean): Promise<string> {
async presign(
bucket: string,
key: string,
method: string,
download?: boolean,
filename?: string,
): Promise<string> {
if (method !== 'GET' && method !== 'PUT') {
throw new Error(`Invalid method: ${method}`)
}
@@ -471,6 +521,9 @@ export class LocalStorageService implements S3Service {
let url = `${this.endpoint}/files/${bucket}/${key}`
if (download) {
url += '?download=1'
if (filename) {
url += `&filename=${encodeURIComponent(filename)}`
}
}
return url
}
+16
View File
@@ -29,3 +29,19 @@ export class ShareLinkPasswordInvalidError extends Error {
Object.setPrototypeOf(this, ShareLinkPasswordInvalidError.prototype)
}
}
export class ShareLinkDownloadDisabledError extends Error {
constructor(message: string) {
super(message)
this.name = 'ShareLinkDownloadDisabledError'
Object.setPrototypeOf(this, ShareLinkDownloadDisabledError.prototype)
}
}
export class ShareLinkWatermarkProcessingError extends Error {
constructor(message = 'Watermark transcoding is currently in progress') {
super(message)
this.name = 'ShareLinkWatermarkProcessingError'
Object.setPrototypeOf(this, ShareLinkWatermarkProcessingError.prototype)
}
}
+24
View File
@@ -53,6 +53,7 @@ describe('ShareService', () => {
})
expect(shareLink.name).toBe('Public Share')
expect(shareLink.allowDownload).toBe(true)
expect(shareLink.rootFolderId).toBeDefined()
const asset = await prisma.asset.findUnique({
@@ -62,6 +63,18 @@ describe('ShareService', () => {
expect(asset?.projectId).toBe(projectId)
})
it('creates a share link with allowDownload disabled', async () => {
const shareLink = await shareService.createShareLink(projectId, {
name: 'No Download Share',
allowDownload: false,
})
expect(shareLink.allowDownload).toBe(false)
const fetched = await shareService.getShareLink(shareLink.id)
expect(fetched.allowDownload).toBe(false)
})
it('adds multiple assets to share and handles duplicates', async () => {
// Create real assets
const file1 = await prisma.asset.create({
@@ -244,6 +257,17 @@ describe('ShareService', () => {
expect(rootAsset?.name).toBe('New Name')
})
it('updates allowDownload on a share link', async () => {
const shareLink = await shareService.createShareLink(projectId, { name: 'Toggle Share' })
expect(shareLink.allowDownload).toBe(true)
const disabled = await shareService.updateShareLink(shareLink.id, { allowDownload: false })
expect(disabled.allowDownload).toBe(false)
const reEnabled = await shareService.updateShareLink(shareLink.id, { allowDownload: true })
expect(reEnabled.allowDownload).toBe(true)
})
it('deletes a share link', async () => {
const shareLink = await shareService.createShareLink(projectId, { name: 'To Delete' })
await shareService.deleteShareLink(shareLink.id)
+45 -7
View File
@@ -6,9 +6,11 @@ import {
UpdateShareLinkRequest,
ListShareLinksRequest,
AddAssetToShareRequest,
WatermarkConfigSpec,
} from '@shumai/dtos'
import { PaginatedData, paginateQuery } from '@shumai/core/src/pagination'
import { getAvatarUrl } from '@shumai/core/src/user/avatar'
import { watermarkService } from '@shumai/core/src/watermark/watermark'
import {
ShareLinkNotFoundError,
ShareLinkDisabledError,
@@ -63,6 +65,7 @@ export class ShareService {
expireAt: req.expireAt ? new Date(req.expireAt) : null,
password: req.password,
isDisabled: req.isDisabled ?? false,
allowDownload: req.allowDownload ?? true,
defaultSortOrder: req.defaultSortOrder,
viewMode: req.viewMode,
projectId: projectId,
@@ -90,6 +93,7 @@ export class ShareService {
req.expireAt !== undefined ? (req.expireAt ? new Date(req.expireAt) : null) : undefined,
password: req.password,
isDisabled: req.isDisabled,
allowDownload: req.allowDownload,
defaultSortOrder: req.defaultSortOrder,
viewMode: req.viewMode,
fieldVisibility: (req.fieldVisibility as PrismaJson.ShareLinkFieldVisibility) ?? undefined,
@@ -144,13 +148,16 @@ export class ShareService {
)
}
async getShareLink(shareLinkId: string): Promise<ShareLinkInfo> {
const shareLink = await prisma.shareLink.findUnique({
async getShareLink(
shareLinkId: string,
client: Prisma.TransactionClient | typeof prisma = prisma,
): Promise<ShareLinkInfo> {
const shareLink = await client.shareLink.findUnique({
where: { id: shareLinkId },
include: { creator: true },
})
if (!shareLink) throw new ShareLinkNotFoundError('Share link not found')
return await this.toShareLinkInfo(shareLink)
return await this.toShareLinkInfo(shareLink, client)
}
async addAssetToShare(shareLinkId: string, req: AddAssetToShareRequest): Promise<number> {
@@ -202,6 +209,17 @@ export class ShareService {
})
})
if (shareLink.watermarkConfigId) {
await prisma.shareLink.update({
where: { id: shareLinkId },
data: { watermarkStatus: 'processing' },
})
await watermarkService.triggerWatermarkTranscodeForShareLink(
shareLinkId,
shareLink.watermarkConfigId,
)
}
return idsToAdd.length
}
@@ -297,23 +315,43 @@ export class ShareService {
return shareLink
}
// eslint-disable-next-line @typescript-eslint/no-explicit-any
private async toShareLinkInfo(l: any): Promise<ShareLinkInfo> {
private async toShareLinkInfo(
l: Prisma.ShareLinkGetPayload<{ include: { creator: true } }>,
client: Prisma.TransactionClient | typeof prisma = prisma,
): Promise<ShareLinkInfo> {
const isExpired = l.expireAt ? new Date(l.expireAt) < new Date() : false
const avatarUrl = l.creator ? await getAvatarUrl(l.creator.image) : undefined
let watermarkConfig: Prisma.WatermarkConfigGetPayload<Record<string, never>> | null = null
if (l.watermarkConfigId) {
watermarkConfig = await client.watermarkConfig.findUnique({
where: { id: l.watermarkConfigId },
})
}
return {
id: l.id,
name: l.name,
expireAt: l.expireAt?.toISOString(),
isDisabled: l.isDisabled,
allowDownload: l.allowDownload,
hasPassword: !!l.password,
password: l.password,
defaultSortOrder: l.defaultSortOrder,
viewMode: l.viewMode,
defaultSortOrder: l.defaultSortOrder ?? undefined,
viewMode: l.viewMode ?? undefined,
fieldVisibility: l.fieldVisibility as Record<string, boolean> | undefined,
rootFolderId: l.rootFolderId,
projectId: l.projectId,
isExpired,
watermarkConfigId: l.watermarkConfigId,
watermarkStatus: l.watermarkStatus || 'disabled',
watermarkConfig: watermarkConfig
? {
id: watermarkConfig.id,
config: await watermarkService.enrichWatermarkConfigWithPresignedUrls(
watermarkConfig.config as WatermarkConfigSpec,
),
hash: watermarkConfig.hash,
}
: null,
createdAt: l.createdAt.toISOString(),
updatedAt: l.updatedAt.toISOString(),
creator: l.creator ? { id: l.creator.id, name: l.creator.name, image: avatarUrl } : null,
+139 -6
View File
@@ -1,5 +1,5 @@
import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
import { transcodeService } from './transcode'
import { transcodeService, calculatePreviewDimensions } from './transcode'
import { s3Service } from '@shumai/core/src/s3/s3'
import * as path from 'path'
import * as child_process from 'child_process'
@@ -28,6 +28,7 @@ vi.mock('sharp', () => {
toColorspace: vi.fn().mockReturnThis(),
webp: vi.fn().mockReturnThis(),
composite: vi.fn().mockReturnThis(),
png: vi.fn().mockReturnThis(),
toBuffer: vi.fn().mockResolvedValue(Buffer.from('fake-webp-buffer')),
toFile: vi.fn().mockImplementation(async (filePath: string) => {
fs.writeFileSync(filePath, 'fake-webp-data')
@@ -184,18 +185,100 @@ describe('TranscodeService', () => {
)
})
it('should use sharp for image transcoding with sRGB conversion', async () => {
it('should use sharp for image transcoding with sRGB conversion (production 300p spec)', async () => {
const outputFile = path.join(tempDir, 'output.webp')
await transcodeService.transcodeImage('input.png', outputFile, 480, 80)
await transcodeService.transcodeImage('input.png', outputFile, 300, 80, { isPreview: true })
expect(sharp).toHaveBeenCalledWith('input.png', { limitInputPixels: false })
const mockSharp = vi.mocked(sharp).mock.results[0].value
expect(mockSharp.toColorspace).toHaveBeenCalledWith('srgb')
expect(mockSharp.resize).toHaveBeenCalledWith(480, 7680, expect.any(Object))
expect(mockSharp.resize).toHaveBeenCalledWith(400, 300, expect.any(Object))
expect(mockSharp.webp).toHaveBeenCalledWith({ quality: 80 })
expect(mockSharp.toFile).toHaveBeenCalledWith(outputFile)
})
it('should support legacy 480 width fallback shim', async () => {
const outputFile = path.join(tempDir, 'output_legacy.webp')
await transcodeService.transcodeImage('input.png', outputFile, 480, 80)
const mockSharp = vi.mocked(sharp).mock.results[vi.mocked(sharp).mock.results.length - 1].value
expect(mockSharp.resize).toHaveBeenCalledWith(400, 300, expect.any(Object))
})
it('should handle preview and full-res proxy dimension calculations correctly', async () => {
const outputFile = path.join(tempDir, 'out.webp')
// 16:9 source (1920x1080) in preview mode -> 533x300
const mockSharp169 = {
resize: vi.fn().mockReturnThis(),
toColorspace: vi.fn().mockReturnThis(),
webp: vi.fn().mockReturnThis(),
toFile: vi.fn().mockResolvedValue({}),
metadata: vi.fn().mockResolvedValue({ width: 1920, height: 1080 }),
}
// eslint-disable-next-line @typescript-eslint/no-explicit-any
vi.mocked(sharp).mockReturnValueOnce(mockSharp169 as any)
await transcodeService.transcodeImage('169.png', outputFile, 300, 80, { isPreview: true })
expect(mockSharp169.resize).toHaveBeenCalledWith(533, 300, expect.any(Object))
// Small image (200x150) in preview mode -> 200x150
const mockSharpSmall = {
resize: vi.fn().mockReturnThis(),
toColorspace: vi.fn().mockReturnThis(),
webp: vi.fn().mockReturnThis(),
toFile: vi.fn().mockResolvedValue({}),
metadata: vi.fn().mockResolvedValue({ width: 200, height: 150 }),
}
// eslint-disable-next-line @typescript-eslint/no-explicit-any
vi.mocked(sharp).mockReturnValueOnce(mockSharpSmall as any)
await transcodeService.transcodeImage('small.png', outputFile, 300, 80, { isPreview: true })
expect(mockSharpSmall.resize).toHaveBeenCalledWith(200, 150, expect.any(Object))
// 1:10 Tall screenshot (1000x10000) in preview mode -> 53x533
const mockSharpTall = {
resize: vi.fn().mockReturnThis(),
toColorspace: vi.fn().mockReturnThis(),
webp: vi.fn().mockReturnThis(),
toFile: vi.fn().mockResolvedValue({}),
metadata: vi.fn().mockResolvedValue({ width: 1000, height: 10000 }),
}
// eslint-disable-next-line @typescript-eslint/no-explicit-any
vi.mocked(sharp).mockReturnValueOnce(mockSharpTall as any)
await transcodeService.transcodeImage('tall.png', outputFile, 300, 80, { isPreview: true })
expect(mockSharpTall.resize).toHaveBeenCalledWith(53, 533, expect.any(Object))
// Square full-resolution proxy (10000x10000, isPreview: false) -> capped at WEBP_MAX_DIMENSION (7680)
const mockSharpSquareProxy = {
resize: vi.fn().mockReturnThis(),
toColorspace: vi.fn().mockReturnThis(),
webp: vi.fn().mockReturnThis(),
toFile: vi.fn().mockResolvedValue({}),
metadata: vi.fn().mockResolvedValue({ width: 10000, height: 10000 }),
}
// eslint-disable-next-line @typescript-eslint/no-explicit-any
vi.mocked(sharp).mockReturnValueOnce(mockSharpSquareProxy as any)
await transcodeService.transcodeImage('square.png', outputFile, 10000, 90, {
height: 10000,
isPreview: false,
})
expect(mockSharpSquareProxy.resize).toHaveBeenCalledWith(7680, 7680, expect.any(Object))
})
it('should calculate preview dimensions correctly for 300p (short side 300, max long side 533)', () => {
// 16:9 Landscape
expect(calculatePreviewDimensions(1920, 1080)).toEqual({ width: 533, height: 300 })
// 9:16 Portrait
expect(calculatePreviewDimensions(1080, 1920)).toEqual({ width: 300, height: 533 })
// 1:1 Square
expect(calculatePreviewDimensions(1000, 1000)).toEqual({ width: 300, height: 300 })
// 21:9 Ultrawide
expect(calculatePreviewDimensions(2560, 1080)).toEqual({ width: 533, height: 225 })
// 1:10 Tall screenshot (capped at max long side = 533)
expect(calculatePreviewDimensions(1000, 10000)).toEqual({ width: 53, height: 533 })
// Small image (no enlargement)
expect(calculatePreviewDimensions(200, 150)).toEqual({ width: 200, height: 150 })
})
it('should use ImageMagick for PSD image transcoding', async () => {
const outputFile = path.join(tempDir, 'output_psd.webp')
const psdBuffer = Buffer.from('8BPS-fake-psd-content')
@@ -263,7 +346,7 @@ describe('TranscodeService', () => {
expect(sharp).toHaveBeenCalledWith(inputBuffer, { limitInputPixels: false })
const mockSharp = vi.mocked(sharp).mock.results[vi.mocked(sharp).mock.results.length - 1].value
expect(mockSharp.toColorspace).toHaveBeenCalledWith('srgb')
expect(mockSharp.resize).toHaveBeenCalledWith(480, 7680, expect.any(Object))
expect(mockSharp.resize).toHaveBeenCalledWith(400, 300, expect.any(Object))
expect(mockSharp.webp).toHaveBeenCalledWith({ quality: 80 })
expect(mockSharp.toFile).toHaveBeenCalledWith(outputFile)
})
@@ -450,7 +533,7 @@ describe('TranscodeService', () => {
)
expect(child_process.execFile).toHaveBeenCalledWith(
'ffmpeg',
expect.arrayContaining(['-filter_complex', 'scale=w=480:h=-2,tile=10x10']),
expect.arrayContaining(['-filter_complex', 'scale=w=300:h=-2,tile=10x10']),
expect.any(Function),
)
expect(child_process.execFile).toHaveBeenCalledWith(
@@ -763,5 +846,55 @@ describe('TranscodeService', () => {
const stat = fs.statSync(pdfFile)
expect(stat.size).toBeGreaterThan(0)
})
describe('watermark overlay helpers', () => {
it('renderSvgToPng should rasterize the SVG to a PNG buffer', async () => {
const svg = '<svg xmlns="http://www.w3.org/2000/svg"><text>WM</text></svg>'
const result = await transcodeService.renderSvgToPng(svg)
expect(Buffer.isBuffer(result)).toBe(true)
// sharp was invoked with the SVG bytes
expect(sharp).toHaveBeenCalledWith(Buffer.from(svg))
})
it('downscaleImageToPng should resize, normalize to PNG and return dimensions', async () => {
const result = await transcodeService.downscaleImageToPng(Buffer.from('raw-image'), 1024)
expect(result.buffer).toBeDefined()
expect(result.width).toBe(800)
expect(result.height).toBe(600)
// resize limited to the max dimension without enlargement
const resizeCall = vi.mocked(sharp().resize).mock.calls[0] as unknown[]
expect(resizeCall[0]).toBe(1024)
expect(resizeCall[1]).toBe(1024)
expect(resizeCall[2]).toEqual({
fit: 'inside',
withoutEnlargement: true,
})
expect(vi.mocked(sharp().png)).toHaveBeenCalled()
})
it('compositeOverlayToWebpFile should composite the overlay and write a webp file', async () => {
const inputPath = path.join(tempDir, 'input.png')
const outputPath = path.join(tempDir, 'output.webp')
fs.writeFileSync(inputPath, 'fake-input')
await transcodeService.compositeOverlayToWebpFile(
inputPath,
Buffer.from('overlay-png'),
outputPath,
1920,
1080,
)
expect(fs.existsSync(outputPath)).toBe(true)
expect(vi.mocked(sharp().resize)).toHaveBeenCalledWith(1920, 1080, {
fit: 'inside',
})
expect(vi.mocked(sharp().composite)).toHaveBeenCalledWith([
{ input: Buffer.from('overlay-png') },
])
expect(vi.mocked(sharp().webp)).toHaveBeenCalledWith({ quality: 90 })
expect(vi.mocked(sharp().toFile)).toHaveBeenCalledWith(outputPath)
})
})
})
})
+137 -10
View File
@@ -110,6 +110,7 @@ export interface TranscodeVideoParams {
height: number
frameRate?: number | string
disableAudio?: boolean
overlayFile?: string
}
export interface ExtractVideoFramesParams {
@@ -144,6 +145,40 @@ export function isPsdInput(input: string | Buffer): boolean {
input[3] === 0x53
)
}
export function calculatePreviewDimensions(
origW: number,
origH: number,
targetShort = 300,
maxLong = 533,
): { width: number; height: number } {
if (origW <= 0 || origH <= 0) {
return { width: targetShort, height: targetShort }
}
const origShort = Math.min(origW, origH)
const origLong = Math.max(origW, origH)
if (origShort <= targetShort && origLong <= maxLong) {
return { width: origW, height: origH }
}
let scale = targetShort / origShort
const scaledLong = Math.round(origLong * scale)
if (scaledLong > maxLong) {
scale = maxLong / origLong
}
const newW = Math.max(1, Math.round(origW * scale))
const newH = Math.max(1, Math.round(origH * scale))
return { width: newW, height: newH }
}
export interface TranscodeImageOptions {
height?: number | null
isPreview?: boolean
}
export class TranscodeService {
constructor(private readonly prismaClient: typeof prisma = prisma) {}
@@ -339,13 +374,22 @@ export class TranscodeService {
}
async transcodeVideo(params: TranscodeVideoParams): Promise<void> {
let filterComplex = `[0:v]scale=w=${params.width}:h=${params.height}:force_original_aspect_ratio=decrease,scale=w='trunc(iw/2)*2':h='trunc(ih/2)*2'`
let filterComplex: string
const args: string[] = ['-i', params.inputFile]
if (params.overlayFile) {
args.push('-i', params.overlayFile)
filterComplex = `[0:v]scale=${params.width}:${params.height}[vscaled];[vscaled][1:v]overlay=0:0`
} else {
filterComplex = `[0:v]scale=w=${params.width}:h=${params.height}:force_original_aspect_ratio=decrease,scale=w='trunc(iw/2)*2':h='trunc(ih/2)*2'`
}
if (params.frameRate) {
filterComplex += `,fps=${params.frameRate}`
}
filterComplex += '[vout]'
const args = ['-i', params.inputFile, '-filter_complex', filterComplex, '-map', '[vout]']
args.push('-filter_complex', filterComplex, '-map', '[vout]')
if (params.frameRate) {
let calculatedFps: number
@@ -392,8 +436,22 @@ export class TranscodeService {
outputFile: string,
width: number,
quality: number,
height: number | null = null,
heightOrOptions: number | null | TranscodeImageOptions = null,
): Promise<void> {
const height =
typeof heightOrOptions === 'object' && heightOrOptions !== null
? (heightOrOptions.height ?? null)
: heightOrOptions
let isPreview =
typeof heightOrOptions === 'object' && heightOrOptions !== null
? (heightOrOptions.isPreview ?? false)
: false
// Backward compatibility shim for legacy queued tasks or old call signatures passing width 480 or height 0
if (width === 480 || height === 0) {
isPreview = true
}
let input: string | Buffer = inputFile
if (typeof inputFile === 'string' && inputFile.startsWith('http')) {
const resp = await fetch(inputFile)
@@ -404,8 +462,30 @@ export class TranscodeService {
}
const WEBP_MAX_DIMENSION = 7680
const targetW = width > 0 ? Math.min(width, WEBP_MAX_DIMENSION) : WEBP_MAX_DIMENSION
const targetH = height && height > 0 ? Math.min(height, WEBP_MAX_DIMENSION) : WEBP_MAX_DIMENSION
let targetW = width > 0 ? Math.min(width, WEBP_MAX_DIMENSION) : WEBP_MAX_DIMENSION
let targetH = height && height > 0 ? Math.min(height, WEBP_MAX_DIMENSION) : WEBP_MAX_DIMENSION
const sharpInstance = sharp(input, { limitInputPixels: false })
if (isPreview) {
try {
const meta = await sharpInstance.metadata()
if (meta.width && meta.height) {
// Fallback shim: If legacy 480 caller passed width=480, map targetShort to 300
const targetShort = width === 480 ? 300 : width
const maxLong = Math.round((targetShort * 16) / 9)
const dims = calculatePreviewDimensions(meta.width, meta.height, targetShort, maxLong)
targetW = dims.width
targetH = dims.height
}
} catch {
// Fallback to targetW/targetH as calculated above
}
}
// WEBP_MAX_DIMENSION (7680) safety cap is ALWAYS enforced
targetW = Math.min(targetW, WEBP_MAX_DIMENSION)
targetH = Math.min(targetH, WEBP_MAX_DIMENSION)
if (isPsdInput(input)) {
let psdPath: string
@@ -442,8 +522,6 @@ export class TranscodeService {
}
}
const sharpInstance = sharp(input, { limitInputPixels: false })
sharpInstance.toColorspace('srgb').resize(targetW, targetH, {
withoutEnlargement: true,
fit: 'inside',
@@ -459,7 +537,7 @@ export class TranscodeService {
duration: number,
): Promise<void> {
const spriteFps = 100 / duration
const filterComplex = `[0:v]fps=${spriteFps},scale=w=480:h=-2,tile=10x10[sprite_out];[0:v]scale=-2:480:force_original_aspect_ratio=decrease,select='eq(n\\,0)'[thumb_out]`
const filterComplex = `[0:v]fps=${spriteFps},scale=w=300:h=-2,tile=10x10[sprite_out];[0:v]scale=-2:300:force_original_aspect_ratio=decrease,select='eq(n\\,0)'[thumb_out]`
const args = [
'-i',
@@ -547,7 +625,7 @@ export class TranscodeService {
'-i',
path.join(tmpDir, 'frame_%d.png'),
'-filter_complex',
'scale=w=480:h=-2,tile=10x10',
'scale=w=300:h=-2,tile=10x10',
'-frames:v',
'1',
'-c:v',
@@ -560,7 +638,7 @@ export class TranscodeService {
await sharp(firstPagePath, { limitInputPixels: false })
.toColorspace('srgb')
.resize(480, null, { withoutEnlargement: true, fit: 'inside' })
.resize(300, 533, { withoutEnlargement: true, fit: 'inside' })
.webp({ quality: 75 })
.toFile(outputPoster)
@@ -1148,6 +1226,55 @@ export class TranscodeService {
this.removeDir(tmpDir)
}
}
/**
* Renders an SVG string to a PNG buffer. Used by the watermark workflow to
* rasterize the overlay before compositing it onto images or feeding it to
* ffmpeg for video overlays.
*/
async renderSvgToPng(svgString: string): Promise<Buffer> {
return sharp(Buffer.from(svgString)).png().toBuffer()
}
/**
* Downscales an image buffer to a bounded size and normalizes it to PNG.
* Used for watermark block images embedded into the SVG overlay, so large
* logo assets don't balloon the SVG/base64 payload.
*/
async downscaleImageToPng(
buffer: Buffer,
maxDimension: number,
): Promise<{ buffer: Buffer; width: number; height: number }> {
const processed = await sharp(buffer, { limitInputPixels: false })
.resize(maxDimension, maxDimension, { fit: 'inside', withoutEnlargement: true })
.png()
.toBuffer()
const meta = await sharp(processed).metadata()
return {
buffer: processed,
width: meta.width || 100,
height: meta.height || 100,
}
}
/**
* Composites an overlay PNG onto an image file and writes a WebP file.
* Used by the watermark workflow to produce watermarked image proxies.
*/
async compositeOverlayToWebpFile(
inputPath: string,
overlayPngBuffer: Buffer,
outputPath: string,
width: number,
height: number,
): Promise<void> {
await sharp(inputPath, { limitInputPixels: false })
.toColorspace('srgb')
.resize(width, height, { fit: 'inside' })
.composite([{ input: overlayPngBuffer }])
.webp({ quality: 90 })
.toFile(outputPath)
}
}
function renderAnnotationsToSvg(
+127
View File
@@ -2,6 +2,7 @@ import { describe, expect, it, vi, beforeEach } from 'vitest'
import { prisma } from '@shumai/db'
import { setupTestDbHooks } from '@shumai/db/test'
import { uploadService } from './upload'
import { gotenbergService } from '@shumai/core/src/gotenberg/gotenberg'
import { s3Service } from '@shumai/core/src/s3/s3'
import { AssetStatus, AssetType, WorkflowTaskType } from '@shumai/db'
@@ -262,6 +263,132 @@ describe('UploadService', () => {
expect(workflowTask).toBeNull()
})
it('should confirm file upload and create transcode_pdf for office document when Gotenberg is available', async () => {
vi.spyOn(gotenbergService, 'isAvailable').mockResolvedValue(true)
const task = await prisma.task.create({
data: { creatorId: userId, total: 1, uploaded: 0, type: 'upload' },
})
const asset = await prisma.asset.create({
data: {
name: 'document.docx',
type: AssetType.file,
project: { connect: { id: projectId } },
parent: { connect: { id: parentId } },
status: AssetStatus.uploading,
storageKey: {
connectOrCreate: {
where: { key: 'test-key' },
create: { key: 'test-key' },
},
},
mediaType: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
},
})
await uploadService.confirmFileUpload(userId, task.id, { fileId: asset.id })
const workflowTask = await prisma.workflowTask.findFirst({
where: { assetId: asset.id, type: WorkflowTaskType.transcode_pdf },
})
expect(workflowTask).toBeDefined()
})
it('should mark asset processed without creating transcode_pdf for office document when Gotenberg is unavailable', async () => {
vi.spyOn(gotenbergService, 'isAvailable').mockResolvedValue(false)
const task = await prisma.task.create({
data: { creatorId: userId, total: 1, uploaded: 0, type: 'upload' },
})
const asset = await prisma.asset.create({
data: {
name: 'document.docx',
type: AssetType.file,
project: { connect: { id: projectId } },
parent: { connect: { id: parentId } },
status: AssetStatus.uploading,
storageKey: {
connectOrCreate: {
where: { key: 'test-key' },
create: { key: 'test-key' },
},
},
mediaType: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
},
})
await uploadService.confirmFileUpload(userId, task.id, { fileId: asset.id })
const updatedAsset = await prisma.asset.findUnique({ where: { id: asset.id } })
expect(updatedAsset?.status).toBe(AssetStatus.processed)
const workflowTask = await prisma.workflowTask.findFirst({
where: { assetId: asset.id, type: WorkflowTaskType.transcode_pdf },
})
expect(workflowTask).toBeNull()
})
it('should confirm file upload and create transcode_pdf for HTML document when Gotenberg is available', async () => {
vi.spyOn(gotenbergService, 'isAvailable').mockResolvedValue(true)
const task = await prisma.task.create({
data: { creatorId: userId, total: 1, uploaded: 0, type: 'upload' },
})
const asset = await prisma.asset.create({
data: {
name: 'index.html',
type: AssetType.file,
project: { connect: { id: projectId } },
parent: { connect: { id: parentId } },
status: AssetStatus.uploading,
storageKey: {
connectOrCreate: {
where: { key: 'test-key-html-1' },
create: { key: 'test-key-html-1' },
},
},
mediaType: 'text/html',
},
})
await uploadService.confirmFileUpload(userId, task.id, { fileId: asset.id })
const workflowTask = await prisma.workflowTask.findFirst({
where: { assetId: asset.id, type: WorkflowTaskType.transcode_pdf },
})
expect(workflowTask).toBeDefined()
})
it('should mark asset processed without creating transcode_pdf for HTML document when Gotenberg is unavailable', async () => {
vi.spyOn(gotenbergService, 'isAvailable').mockResolvedValue(false)
const task = await prisma.task.create({
data: { creatorId: userId, total: 1, uploaded: 0, type: 'upload' },
})
const asset = await prisma.asset.create({
data: {
name: 'index.html',
type: AssetType.file,
project: { connect: { id: projectId } },
parent: { connect: { id: parentId } },
status: AssetStatus.uploading,
storageKey: {
connectOrCreate: {
where: { key: 'test-key-html-2' },
create: { key: 'test-key-html-2' },
},
},
mediaType: 'text/html',
},
})
await uploadService.confirmFileUpload(userId, task.id, { fileId: asset.id })
const updatedAsset = await prisma.asset.findUnique({ where: { id: asset.id } })
expect(updatedAsset?.status).toBe(AssetStatus.processed)
const workflowTask = await prisma.workflowTask.findFirst({
where: { assetId: asset.id, type: WorkflowTaskType.transcode_pdf },
})
expect(workflowTask).toBeNull()
})
it('should confirm file upload and resolve empty mediaType using Bun resolver for audio', async () => {
const task = await prisma.task.create({
data: { creatorId: userId, total: 1, uploaded: 0, type: 'upload' },
+16 -1
View File
@@ -13,8 +13,9 @@ import {
import { ImageTranscoder, PdfTranscoder, VideoTranscoder } from '@shumai/transcode'
import { generateKeyBetween } from 'jittered-fractional-indexing'
import { ulid } from 'ulid'
import { gotenbergService } from '@shumai/core/src/gotenberg/gotenberg'
import { sanitizeFilename } from '@shumai/core/src/utils/filename'
import { getProxyType } from '@shumai/core/src/utils/mime'
import { getProxyType, isHtmlDocument, isOfficeDocument } from '@shumai/core/src/utils/mime'
export class UploadService {
constructor(private readonly prismaClient: typeof prisma = prisma) {}
@@ -315,6 +316,20 @@ export class UploadService {
// eslint-disable-next-line @typescript-eslint/no-explicit-any
await new ImageTranscoder(tx as any, asset.id, team.id, projectId).withThumbnail().submit()
} else if (isPdf) {
const isOffice = isOfficeDocument(asset.mediaType, asset.name)
const isHtml = isHtmlDocument(asset.mediaType, asset.name)
if (isOffice || isHtml) {
const gotenbergAvailable = await gotenbergService.isAvailable()
if (!gotenbergAvailable) {
await tx.asset.update({
where: { id: asset.id },
data: { status: AssetStatus.processed },
})
return
}
}
// eslint-disable-next-line @typescript-eslint/no-explicit-any
await new PdfTranscoder(tx as any, asset.id, team.id, projectId)
.withSprite()
+46 -8
View File
@@ -1,5 +1,12 @@
import { describe, it, expect } from 'vitest'
import { detectSupportedMimeType, getProxyType } from './mime'
import {
detectSupportedMimeType,
getProxyType,
isOfficeDocument,
isHtmlDocument,
isMarkdownDocument,
isCsvDocument,
} from './mime'
describe('detectSupportedMimeType', () => {
it('should detect JPEG', () => {
@@ -45,6 +52,38 @@ describe('detectSupportedMimeType', () => {
})
})
describe('document helpers', () => {
it('isOfficeDocument should correctly identify office files', () => {
expect(isOfficeDocument('application/msword', 'letter.doc')).toBe(true)
expect(
isOfficeDocument(
'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
'file.docx',
),
).toBe(true)
expect(isOfficeDocument(null, 'sheet.xlsx')).toBe(true)
expect(isOfficeDocument(null, 'slides.pptx')).toBe(true)
expect(isOfficeDocument(null, 'notes.rtf')).toBe(true)
expect(isOfficeDocument('text/plain', 'notes.txt')).toBe(false)
})
it('isHtmlDocument should correctly identify html files', () => {
expect(isHtmlDocument('text/html', 'page.html')).toBe(true)
expect(isHtmlDocument(null, 'index.htm')).toBe(true)
expect(isHtmlDocument('text/plain', 'notes.txt')).toBe(false)
})
it('isMarkdownDocument should correctly identify markdown files', () => {
expect(isMarkdownDocument('text/markdown', 'README.md')).toBe(true)
expect(isMarkdownDocument(null, 'doc.markdown')).toBe(true)
})
it('isCsvDocument should correctly identify csv files', () => {
expect(isCsvDocument('text/csv', 'data.csv')).toBe(true)
expect(isCsvDocument(null, 'data.csv')).toBe(true)
})
})
describe('getProxyType', () => {
it('should detect image proxyType', () => {
expect(getProxyType('image/png', 'test.png')).toBe('image')
@@ -61,21 +100,20 @@ describe('getProxyType', () => {
expect(getProxyType('audio/mpeg', 'song.mp3')).toBe('audio')
})
it('should detect pdf proxyType only for pdf, csv, txt, and markdown files', () => {
it('should detect pdf proxyType for pdf, csv, txt, markdown, html, and office files', () => {
expect(getProxyType('application/pdf', 'doc.pdf')).toBe('pdf')
expect(getProxyType('text/plain', 'notes.txt')).toBe('pdf')
expect(getProxyType('text/csv', 'data.csv')).toBe('pdf')
expect(getProxyType('text/markdown', 'README.md')).toBe('pdf')
expect(getProxyType('text/x-markdown', 'doc.markdown')).toBe('pdf')
expect(getProxyType(null, 'file.txt')).toBe('pdf')
expect(getProxyType(null, 'README.md')).toBe('pdf')
expect(getProxyType(null, 'doc.markdown')).toBe('pdf')
expect(getProxyType('text/html', 'index.html')).toBe('pdf')
expect(getProxyType('application/msword', 'letter.doc')).toBe('pdf')
expect(getProxyType(null, 'sheet.xlsx')).toBe('pdf')
expect(getProxyType(null, 'slides.pptx')).toBe('pdf')
})
it('should return null for unsupported files including office files', () => {
it('should return null for unsupported files', () => {
expect(getProxyType('application/zip', 'archive.zip')).toBeNull()
expect(getProxyType('application/msword', 'letter.doc')).toBeNull()
expect(getProxyType(null, 'sheet.xlsx')).toBeNull()
expect(getProxyType(null, 'unknown.bin')).toBeNull()
})
})
+70 -6
View File
@@ -1,5 +1,71 @@
export type ProxyType = 'image' | 'video' | 'audio' | 'pdf'
export function isOfficeDocument(mediaType?: string | null, filename?: string | null): boolean {
const lowerMediaType = mediaType?.toLowerCase() || ''
const lowerFilename = filename?.toLowerCase() || ''
if (
lowerMediaType === 'application/msword' ||
lowerMediaType === 'application/vnd.openxmlformats-officedocument.wordprocessingml.document' ||
lowerMediaType === 'application/vnd.ms-excel' ||
lowerMediaType === 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet' ||
lowerMediaType === 'application/vnd.ms-powerpoint' ||
lowerMediaType ===
'application/vnd.openxmlformats-officedocument.presentationml.presentation' ||
lowerMediaType === 'application/vnd.oasis.opendocument.text' ||
lowerMediaType === 'application/vnd.oasis.opendocument.spreadsheet' ||
lowerMediaType === 'application/vnd.oasis.opendocument.presentation' ||
lowerMediaType === 'application/rtf' ||
lowerMediaType === 'text/rtf'
) {
return true
}
const officeExtensions = [
'.doc',
'.docx',
'.xls',
'.xlsx',
'.ppt',
'.pptx',
'.odt',
'.ods',
'.odp',
'.rtf',
]
return officeExtensions.some((ext) => lowerFilename.endsWith(ext))
}
export function isHtmlDocument(mediaType?: string | null, filename?: string | null): boolean {
const lowerMediaType = mediaType?.toLowerCase() || ''
const lowerFilename = filename?.toLowerCase() || ''
return (
lowerMediaType === 'text/html' ||
lowerFilename.endsWith('.html') ||
lowerFilename.endsWith('.htm')
)
}
export function isMarkdownDocument(mediaType?: string | null, filename?: string | null): boolean {
const lowerMediaType = mediaType?.toLowerCase() || ''
const lowerFilename = filename?.toLowerCase() || ''
return (
lowerMediaType === 'text/markdown' ||
lowerMediaType === 'text/x-markdown' ||
lowerFilename.endsWith('.md') ||
lowerFilename.endsWith('.markdown')
)
}
export function isCsvDocument(mediaType?: string | null, filename?: string | null): boolean {
const lowerMediaType = mediaType?.toLowerCase() || ''
const lowerFilename = filename?.toLowerCase() || ''
return lowerMediaType === 'text/csv' || lowerFilename.endsWith('.csv')
}
export function getProxyType(
mediaType?: string | null,
filename?: string | null,
@@ -14,14 +80,12 @@ export function getProxyType(
if (
lowerMediaType === 'application/pdf' ||
lowerMediaType === 'text/plain' ||
lowerMediaType === 'text/csv' ||
lowerMediaType === 'text/markdown' ||
lowerMediaType === 'text/x-markdown' ||
lowerFilename.endsWith('.pdf') ||
lowerFilename.endsWith('.txt') ||
lowerFilename.endsWith('.csv') ||
lowerFilename.endsWith('.md') ||
lowerFilename.endsWith('.markdown')
isCsvDocument(mediaType, filename) ||
isMarkdownDocument(mediaType, filename) ||
isHtmlDocument(mediaType, filename) ||
isOfficeDocument(mediaType, filename)
) {
return 'pdf'
}
@@ -0,0 +1,14 @@
import type { WatermarkConfigSpec } from '@shumai/dtos'
export function computeWatermarkConfigHash(config: WatermarkConfigSpec): string {
const blockStrings = config.blocks.map((block) => {
if (block.type === 'text') {
return `text|x:${block.x.toFixed(4)}|y:${block.y.toFixed(4)}|op:${block.opacity.toFixed(2)}|rot:${block.rotation.toFixed(2)}|sz:${block.size.toFixed(4)}|col:${block.color.toLowerCase()}|txt:${block.text}`
} else {
return `image|x:${block.x.toFixed(4)}|y:${block.y.toFixed(4)}|op:${block.opacity.toFixed(2)}|rot:${block.rotation.toFixed(2)}|sz:${block.size.toFixed(4)}|img:${block.imageAssetKey}`
}
})
blockStrings.sort()
const str = blockStrings.join(';')
return Bun.hash(str).toString(16)
}
@@ -0,0 +1,66 @@
import type { WatermarkConfigSpec } from '@shumai/dtos'
export interface RenderBlockImageData {
imageAssetKey: string
base64Data: string
mimeType: string
width: number
height: number
}
function escapeXml(unsafe: string): string {
return unsafe
.replace(/&/g, '&amp;')
.replace(/</g, '&lt;')
.replace(/>/g, '&gt;')
.replace(/"/g, '&quot;')
.replace(/'/g, '&apos;')
}
export function generateWatermarkSvg(
config: WatermarkConfigSpec,
canvasWidth: number,
canvasHeight: number,
blockImagesMap: Map<string, RenderBlockImageData> = new Map(),
): string {
const elements: string[] = []
for (const block of config.blocks) {
const cx = canvasWidth * block.x
const cy = canvasHeight * block.y
const opacity = Math.max(0, Math.min(1, block.opacity))
const rotation = block.rotation || 0
if (block.type === 'text') {
// block.size is a FRACTION of the canvas width (0..1), so the watermark
// scales proportionally with the output resolution. The editor must store
// size as a fraction too (it converts from its %/px UI controls).
const fontSize = Math.max(1, Math.round(canvasWidth * block.size))
const textContent = escapeXml(block.text || '')
const fill = escapeXml(block.color || '#FFFFFF')
elements.push(
`<text x="${cx}" y="${cy}" text-anchor="middle" dominant-baseline="central" font-family="sans-serif" font-size="${fontSize}" font-weight="bold" fill="${fill}" opacity="${opacity}" transform="rotate(${rotation}, ${cx}, ${cy})">${textContent}</text>`,
)
} else if (block.type === 'image') {
const imageData = blockImagesMap.get(block.imageAssetKey)
if (!imageData) continue
// Fraction of canvas width, same as the text blocks above.
const targetWidth = Math.max(1, Math.round(canvasWidth * block.size))
const aspectRatio = imageData.height > 0 ? imageData.width / imageData.height : 1
const targetHeight = Math.max(1, Math.round(targetWidth / aspectRatio))
const x = cx - targetWidth / 2
const y = cy - targetHeight / 2
elements.push(
`<image x="${x}" y="${y}" width="${targetWidth}" height="${targetHeight}" href="data:${imageData.mimeType};base64,${imageData.base64Data}" opacity="${opacity}" transform="rotate(${rotation}, ${cx}, ${cy})"/>`,
)
}
}
return `<svg xmlns="http://www.w3.org/2000/svg" width="${canvasWidth}" height="${canvasHeight}">${elements.join(
'\n',
)}</svg>`
}
@@ -0,0 +1,543 @@
import { prisma } from '@shumai/db'
import { setupTestDbHooks } from '@shumai/db/test'
import { watermarkService } from '@shumai/core/src/watermark/watermark'
import { generateWatermarkSvg } from '@shumai/core/src/watermark/watermark-svg'
import { shareService } from '@shumai/core/src/share/share'
import { teamService } from '@shumai/core/src/team/team'
import { s3Service } from '@shumai/core/src/s3/s3'
import { computeWatermarkConfigHash } from '@shumai/core/src/watermark/watermark-hash'
import type { WatermarkConfigSpec } from '@shumai/dtos'
import { beforeEach, describe, expect, it, vi } from 'vitest'
describe('WatermarkService', () => {
setupTestDbHooks()
const sampleConfig: WatermarkConfigSpec = {
blocks: [
{
id: 'block-1',
type: 'text',
x: 0.5,
y: 0.5,
opacity: 0.8,
rotation: -30,
text: 'CONFIDENTIAL',
size: 0.2,
color: '#FF0000',
},
],
}
it('should compute deterministic hash ignoring block id and block order', () => {
const config1: WatermarkConfigSpec = {
blocks: [
{
id: 'b1',
type: 'text',
x: 0.5,
y: 0.5,
opacity: 0.5,
rotation: 0,
text: 'A',
size: 0.1,
color: '#FFFFFF',
},
{
id: 'b2',
type: 'text',
x: 0.1,
y: 0.1,
opacity: 0.9,
rotation: 15,
text: 'B',
size: 0.2,
color: '#000000',
},
],
}
const config2: WatermarkConfigSpec = {
blocks: [
{
id: 'other-id-2',
type: 'text',
x: 0.1,
y: 0.1,
opacity: 0.9,
rotation: 15,
text: 'B',
size: 0.2,
color: '#000000',
},
{
id: 'other-id-1',
type: 'text',
x: 0.5,
y: 0.5,
opacity: 0.5,
rotation: 0,
text: 'A',
size: 0.1,
color: '#FFFFFF',
},
],
}
const hash1 = computeWatermarkConfigHash(config1)
const hash2 = computeWatermarkConfigHash(config2)
expect(hash1).toBe(hash2)
})
it('should generate SVG overlay XML', () => {
const svg = generateWatermarkSvg(sampleConfig, 1000, 500)
expect(svg).toContain('<svg')
expect(svg).toContain('CONFIDENTIAL')
expect(svg).toContain('fill="#FF0000"')
})
it('should upsert watermark config by hash', async () => {
const config1 = await watermarkService.upsertConfig(sampleConfig)
expect(config1.id).toBeDefined()
const config2 = await watermarkService.upsertConfig(sampleConfig)
expect(config2.id).toBe(config1.id)
})
it('should not race when upserting the same config concurrently', async () => {
const results = await Promise.all(
Array.from({ length: 10 }, () => watermarkService.upsertConfig(sampleConfig)),
)
const ids = new Set(results.map((r) => r.id))
expect(ids.size).toBe(1)
})
it('should manage watermark templates (CRUD)', async () => {
const user = await prisma.user.create({
data: { name: 'Test User', email: 'test-wm-tpl@example.com' },
})
const team = await teamService.createTeam(user, { name: 'Watermark Team' })
const created = await watermarkService.createTemplate(team.id, 'Draft Preset', sampleConfig)
expect(created.id).toBeDefined()
expect(created.name).toBe('Draft Preset')
const list = await watermarkService.listTemplates(team.id)
expect(list.length).toBe(1)
const updated = await watermarkService.updateTemplate(created.id, 'Final Preset')
expect(updated.name).toBe('Final Preset')
const fetched = await watermarkService.getTemplate(created.id)
expect(fetched.name).toBe('Final Preset')
await watermarkService.deleteTemplate(created.id)
const emptyList = await watermarkService.listTemplates(team.id)
expect(emptyList.length).toBe(0)
})
it('should update sharelink watermark and dispatch transcode tasks', async () => {
const user = await prisma.user.create({
data: { name: 'Share User', email: 'share-wm@example.com' },
})
const team = await teamService.createTeam(user, { name: 'Share Team' })
const projectFolder = await prisma.asset.create({
data: { name: 'root', type: 'root', status: 'processed' },
})
const project = await prisma.project.create({
data: { name: 'Test Project', teamId: team.id, rootFolderId: projectFolder.id },
})
const shareLink = await shareService.createShareLink(project.id, { name: 'My Share' }, user.id)
// Add a file asset to project and share link
const asset = await prisma.asset.create({
data: {
name: 'sample.mp4',
type: 'file',
mediaType: 'video/mp4',
status: 'processed',
projectId: project.id,
},
})
await shareService.addAssetToShare(shareLink.id, { assetIds: [asset.id] })
// Update sharelink watermark -> enable
const updated = await watermarkService.updateShareLinkWatermark(
shareLink.id,
true,
sampleConfig,
)
expect(updated.watermarkStatus).toBe('processing')
expect(updated.watermarkConfigId).toBeDefined()
// Verify WorkflowTask was created
const tasks = await prisma.workflowTask.findMany({
where: { assetId: asset.id, type: 'transcode_watermark' },
})
expect(tasks.length).toBeGreaterThan(0)
// eslint-disable-next-line @typescript-eslint/no-explicit-any
expect((tasks[0].payload as any)?.watermark?.watermarkConfigId).toBe(updated.watermarkConfigId)
// Attempting update while status is processing should throw conflict error
await expect(
watermarkService.updateShareLinkWatermark(shareLink.id, true, sampleConfig),
).rejects.toThrow('Watermark transcoding is currently in progress')
// Simulate completion of transcoding
await prisma.shareLink.update({
where: { id: shareLink.id },
data: { watermarkStatus: 'ready' },
})
// Disable watermark after ready
const disabled = await watermarkService.updateShareLinkWatermark(shareLink.id, false)
expect(disabled.watermarkStatus).toBe('disabled')
expect(disabled.watermarkConfigId).toBeNull()
})
it('should resolve media assets including nested symlinks in shared folders', async () => {
const user = await prisma.user.create({
data: { name: 'Nested User', email: 'nested-wm@example.com' },
})
const team = await teamService.createTeam(user, { name: 'Nested Team' })
const projectFolder = await prisma.asset.create({
data: { name: 'root', type: 'root', status: 'processed' },
})
const project = await prisma.project.create({
data: { name: 'Nested Project', teamId: team.id, rootFolderId: projectFolder.id },
})
const shareLink = await shareService.createShareLink(
project.id,
{ name: 'Nested Share' },
user.id,
)
// Shared folder -> inner folder -> symlink -> media file
const sharedFolder = await prisma.asset.create({
data: { name: 'shared', type: 'folder', status: 'processed', projectId: project.id },
})
const innerFolder = await prisma.asset.create({
data: { name: 'inner', type: 'folder', status: 'processed', projectId: project.id },
})
const mediaFile = await prisma.asset.create({
data: {
name: 'clip.mp4',
type: 'file',
mediaType: 'video/mp4',
status: 'processed',
projectId: project.id,
parentId: innerFolder.id,
},
})
// symlink inside the shared folder points at the inner folder
await prisma.asset.create({
data: {
name: 'inner-link',
type: 'symlink',
status: 'processed',
projectId: project.id,
parentId: sharedFolder.id,
targetId: innerFolder.id,
},
})
// root symlink for the share points at the shared folder
await prisma.asset.create({
data: {
name: 'shared-link',
type: 'symlink',
status: 'processed',
projectId: project.id,
parentId: shareLink.rootFolderId,
targetId: sharedFolder.id,
},
})
const mediaIds = await watermarkService.getMediaAssetIdsInShareLink(shareLink.rootFolderId)
expect(mediaIds).toContain(mediaFile.id)
})
describe('purgeOrphanWatermarkConfigs', () => {
const bucket = 'shumai-gc-test-bucket'
beforeEach(() => {
vi.restoreAllMocks()
process.env.S3_BUCKET = bucket
})
// Media with every proxy slot the GC should delete from S3 (plus an
// `original` key that must survive).
function proxyMedia(): PrismaJson.MediaInfo {
return {
duration: 0,
filesize: 100,
frames: 0,
proxyType: 'video',
videoTranscodes: [
{ key: 'files/gc/wm.mp4', width: 1920, height: 1080, resolution: '1080p' },
],
imageTranscodes: [
{ key: 'files/gc/wm.webp', width: 1280, height: 720, quality: 90, format: 'webp' },
],
videoPreview: { key: 'files/gc/preview.mp4', width: 1280, height: 720 },
thumbnail: {
key: 'files/gc/thumb.webp',
width: 320,
height: 180,
quality: 90,
format: 'webp',
},
finishedAt: new Date().toISOString(),
metadata: null,
original: { key: 'files/gc/original.mp4', filesizeInBytes: 0, codec: '' },
}
}
async function seedProject() {
const team = await prisma.team.create({ data: { name: 'GC Team' } })
const projectFolder = await prisma.asset.create({
data: { name: 'root', type: 'root', status: 'processed' },
})
return prisma.project.create({
data: { name: 'GC Project', teamId: team.id, rootFolderId: projectFolder.id },
})
}
async function seedConfigWithWatermarkFile(config: WatermarkConfigSpec = sampleConfig) {
const asset = await prisma.asset.create({
data: { name: 'gc-asset.mp4', type: 'file', mediaType: 'video/mp4', status: 'processed' },
})
const wmConfig = await watermarkService.upsertConfig(config)
const watermarkFile = await prisma.watermarkFile.create({
data: {
assetId: asset.id,
watermarkConfigId: wmConfig.id,
status: 'completed',
media: proxyMedia(),
},
})
return { asset, config: wmConfig, watermarkFile }
}
async function seedWatermarkTask(
assetId: string,
projectId: string,
configId: string,
status: 'pending' | 'processing' | 'completed',
type: 'transcode_watermark' | 'transcode_video' = 'transcode_watermark',
) {
return prisma.workflowTask.create({
data: {
assetId,
projectId,
type,
status,
payload: {
projectId,
watermark: { watermarkConfigId: configId },
},
},
})
}
it('should purge an orphan config, delete its S3 proxies and keep the original key', async () => {
const { config, watermarkFile } = await seedConfigWithWatermarkFile()
const deleteSpy = vi.spyOn(s3Service, 'deleteObject').mockResolvedValue(0)
const purgedCount = await watermarkService.purgeOrphanWatermarkConfigs()
expect(purgedCount).toBe(1)
expect(await prisma.watermarkConfig.findUnique({ where: { id: config.id } })).toBeNull()
expect(await prisma.watermarkFile.findUnique({ where: { id: watermarkFile.id } })).toBeNull()
// All proxy slots deleted, but the original file is never touched
for (const key of [
'files/gc/wm.mp4',
'files/gc/wm.webp',
'files/gc/preview.mp4',
'files/gc/thumb.webp',
]) {
expect(deleteSpy).toHaveBeenCalledWith(bucket, key)
}
expect(deleteSpy).not.toHaveBeenCalledWith(bucket, 'files/gc/original.mp4')
expect(deleteSpy).toHaveBeenCalledTimes(4)
})
it('should NOT purge a config still referenced by a share link', async () => {
const { config } = await seedConfigWithWatermarkFile()
const project = await seedProject()
const shareFolder = await prisma.asset.create({
data: { name: 'share-folder', type: 'share', status: 'processed', projectId: project.id },
})
await prisma.shareLink.create({
data: {
name: 'GC Share',
projectId: project.id,
rootFolderId: shareFolder.id,
watermarkConfigId: config.id,
},
})
const deleteSpy = vi.spyOn(s3Service, 'deleteObject').mockResolvedValue(0)
const purgedCount = await watermarkService.purgeOrphanWatermarkConfigs()
expect(purgedCount).toBe(0)
expect(await prisma.watermarkConfig.findUnique({ where: { id: config.id } })).not.toBeNull()
expect(deleteSpy).not.toHaveBeenCalled()
})
it.each(['pending', 'processing'] as const)(
'should NOT purge a config with an in-flight %s watermark task',
async (status) => {
const { asset, config } = await seedConfigWithWatermarkFile()
const project = await seedProject()
await seedWatermarkTask(asset.id, project.id, config.id, status)
const deleteSpy = vi.spyOn(s3Service, 'deleteObject').mockResolvedValue(0)
const purgedCount = await watermarkService.purgeOrphanWatermarkConfigs()
expect(purgedCount).toBe(0)
expect(await prisma.watermarkConfig.findUnique({ where: { id: config.id } })).not.toBeNull()
expect(deleteSpy).not.toHaveBeenCalled()
},
)
it('should purge a config once its watermark tasks are all completed', async () => {
const { asset, config } = await seedConfigWithWatermarkFile()
const project = await seedProject()
await seedWatermarkTask(asset.id, project.id, config.id, 'completed')
vi.spyOn(s3Service, 'deleteObject').mockResolvedValue(0)
const purgedCount = await watermarkService.purgeOrphanWatermarkConfigs()
expect(purgedCount).toBe(1)
expect(await prisma.watermarkConfig.findUnique({ where: { id: config.id } })).toBeNull()
})
it('should ignore pending tasks of other types when deciding to purge', async () => {
const { asset, config } = await seedConfigWithWatermarkFile()
const project = await seedProject()
// A pending transcode_video task must not protect the watermark config
await seedWatermarkTask(asset.id, project.id, config.id, 'pending', 'transcode_video')
vi.spyOn(s3Service, 'deleteObject').mockResolvedValue(0)
const purgedCount = await watermarkService.purgeOrphanWatermarkConfigs()
expect(purgedCount).toBe(1)
expect(await prisma.watermarkConfig.findUnique({ where: { id: config.id } })).toBeNull()
})
it('should keep purging other configs and S3 keys when one S3 delete fails', async () => {
const { config } = await seedConfigWithWatermarkFile()
const deleteSpy = vi
.spyOn(s3Service, 'deleteObject')
.mockRejectedValueOnce(new Error('s3 down'))
.mockResolvedValue(0)
const purgedCount = await watermarkService.purgeOrphanWatermarkConfigs()
expect(purgedCount).toBe(1)
expect(await prisma.watermarkConfig.findUnique({ where: { id: config.id } })).toBeNull()
// All 4 proxy keys were attempted even though the first one failed
expect(deleteSpy).toHaveBeenCalledTimes(4)
})
it('should purge only the orphan config when another config is still referenced', async () => {
const otherConfig: WatermarkConfigSpec = {
blocks: [
{
id: 'other-block',
type: 'text',
x: 0.3,
y: 0.3,
opacity: 0.4,
rotation: 10,
text: 'OTHER TEAM',
size: 0.1,
color: '#00FF00',
},
],
}
const orphan = await seedConfigWithWatermarkFile()
const referenced = await seedConfigWithWatermarkFile(otherConfig)
const project = await seedProject()
const shareFolder = await prisma.asset.create({
data: { name: 'share-folder', type: 'share', status: 'processed', projectId: project.id },
})
await prisma.shareLink.create({
data: {
name: 'GC Share',
projectId: project.id,
rootFolderId: shareFolder.id,
watermarkConfigId: referenced.config.id,
},
})
vi.spyOn(s3Service, 'deleteObject').mockResolvedValue(0)
const purgedCount = await watermarkService.purgeOrphanWatermarkConfigs()
expect(purgedCount).toBe(1)
expect(
await prisma.watermarkConfig.findUnique({ where: { id: orphan.config.id } }),
).toBeNull()
expect(
await prisma.watermarkConfig.findUnique({ where: { id: referenced.config.id } }),
).not.toBeNull()
})
})
it('should fetch completed watermark media map for asset IDs', async () => {
const config = await watermarkService.upsertConfig(sampleConfig)
const asset1 = await prisma.asset.create({
data: { name: 'asset1.png', type: 'file', status: 'processed' },
})
const asset2 = await prisma.asset.create({
data: { name: 'asset2.png', type: 'file', status: 'processed' },
})
const sampleMedia: PrismaJson.MediaInfo = {
duration: 0,
filesize: 100,
frames: 0,
proxyType: 'image',
imageTranscodes: [
{ key: 'watermarked.webp', width: 100, height: 100, quality: 90, format: 'webp' },
],
videoTranscodes: [],
finishedAt: new Date().toISOString(),
metadata: null,
original: null,
}
await prisma.watermarkFile.create({
data: {
assetId: asset1.id,
watermarkConfigId: config.id,
status: 'completed',
media: sampleMedia,
},
})
// asset2 has pending status
await prisma.watermarkFile.create({
data: {
assetId: asset2.id,
watermarkConfigId: config.id,
status: 'pending',
},
})
const map = await watermarkService.getCompletedWatermarkMediaMap(
[asset1.id, asset2.id],
config.id,
)
expect(map.size).toBe(1)
expect(map.get(asset1.id)).toBeDefined()
expect(map.get(asset1.id)?.imageTranscodes[0].key).toBe('watermarked.webp')
expect(map.get(asset2.id)).toBeUndefined()
})
})
+584
View File
@@ -0,0 +1,584 @@
import {
prisma,
WorkflowTaskStatus,
WorkflowTaskType,
WatermarkStatus,
WatermarkFileStatus,
WatermarkConfig,
WatermarkTemplate,
} from '@shumai/db'
import type { Prisma } from '@shumai/db'
import '@shumai/db/src/prisma-json-types'
import {
WatermarkConfigSpec,
WatermarkConfigInfo,
WatermarkTemplateInfo,
ShareLinkInfo,
} from '@shumai/dtos'
import { computeWatermarkConfigHash } from '@shumai/core/src/watermark/watermark-hash'
import { s3Service } from '@shumai/core/src/s3/s3'
import {
ShareLinkNotFoundError,
ShareLinkWatermarkProcessingError,
} from '@shumai/core/src/share/errors'
import { shareService } from '@shumai/core/src/share/share'
import { logger } from '@shumai/core/src/logger'
// Union of the global client and interactive-transaction client, which share the
// same delegate shapes for the models used by this service.
type WatermarkDbClient = Prisma.TransactionClient | typeof prisma
export class WatermarkService {
constructor(private readonly prismaClient: typeof prisma = prisma) {}
async upsertConfig(config: WatermarkConfigSpec) {
return this.upsertConfigWithClient(this.prismaClient, config)
}
private async upsertConfigWithClient(client: WatermarkDbClient, config: WatermarkConfigSpec) {
const hash = computeWatermarkConfigHash(config)
// Upsert keyed on the unique hash so concurrent enables of the same config
// cannot race into a unique-constraint violation.
return client.watermarkConfig.upsert({
where: { hash },
update: {},
create: {
hash,
config: config as PrismaJson.WatermarkConfigSpec,
},
})
}
// ----------------------------------------------------------------------
// Watermark Template CRUD
// ----------------------------------------------------------------------
async createTemplate(
teamId: string | null,
name: string,
config: WatermarkConfigSpec,
): Promise<WatermarkTemplateInfo> {
const tpl = await this.prismaClient.watermarkTemplate.create({
data: {
name,
config: config as PrismaJson.WatermarkConfigSpec,
teamId,
},
})
return await this.toWatermarkTemplateInfo(tpl)
}
async updateTemplate(
templateId: string,
name?: string,
config?: WatermarkConfigSpec,
): Promise<WatermarkTemplateInfo> {
const existing = await this.prismaClient.watermarkTemplate.findUnique({
where: { id: templateId },
})
if (!existing) {
throw new Error('Watermark template not found')
}
const tpl = await this.prismaClient.watermarkTemplate.update({
where: { id: templateId },
data: {
name: name ?? undefined,
config: config ? (config as PrismaJson.WatermarkConfigSpec) : undefined,
},
})
return await this.toWatermarkTemplateInfo(tpl)
}
async deleteTemplate(templateId: string): Promise<void> {
const existing = await this.prismaClient.watermarkTemplate.findUnique({
where: { id: templateId },
})
if (!existing) {
throw new Error('Watermark template not found')
}
await this.prismaClient.watermarkTemplate.delete({
where: { id: templateId },
})
}
async listTemplates(teamIds?: string | string[] | null): Promise<WatermarkTemplateInfo[]> {
const where = teamIds
? Array.isArray(teamIds)
? { teamId: { in: teamIds } }
: { teamId: teamIds }
: undefined
const tpls = await this.prismaClient.watermarkTemplate.findMany({
where,
// ULIDs are time-sortable; ordering by id desc is the project convention
orderBy: { id: 'desc' },
})
return await Promise.all(tpls.map((t) => this.toWatermarkTemplateInfo(t)))
}
async getTemplate(templateId: string): Promise<WatermarkTemplateInfo> {
const tpl = await this.prismaClient.watermarkTemplate.findUnique({
where: { id: templateId },
})
if (!tpl) {
throw new Error('Watermark template not found')
}
return await this.toWatermarkTemplateInfo(tpl)
}
// ----------------------------------------------------------------------
// ShareLink Watermark Management
// ----------------------------------------------------------------------
async updateShareLinkWatermark(
shareLinkId: string,
enabled: boolean,
config?: WatermarkConfigSpec,
): Promise<ShareLinkInfo> {
return await this.prismaClient.$transaction(async (tx) => {
// Lock the sharelink record SELECT FOR UPDATE
const lockedRows = await tx.$queryRaw<
{
id: string
watermarkStatus: WatermarkStatus
watermarkConfigId: string | null
}[]
>`SELECT id, watermark_status AS "watermarkStatus", watermark_config_id AS "watermarkConfigId" FROM share_links WHERE id = ${shareLinkId} FOR UPDATE`
if (lockedRows.length === 0) {
throw new ShareLinkNotFoundError('Share link not found')
}
const currentStatus = lockedRows[0].watermarkStatus
if (currentStatus === WatermarkStatus.processing) {
throw new ShareLinkWatermarkProcessingError(
'Watermark transcoding is currently in progress',
)
}
if (!enabled) {
await tx.shareLink.update({
where: { id: shareLinkId },
data: {
watermarkConfigId: null,
watermarkStatus: WatermarkStatus.disabled,
},
})
// Read back through the transaction client: the global client runs on a
// different pooled connection and cannot see uncommitted changes.
return await shareService.getShareLink(shareLinkId, tx)
}
if (!config || !config.blocks || config.blocks.length === 0) {
throw new Error('Watermark configuration is required when enabling watermark')
}
// Upsert watermark config based on hash
const watermarkConfig = await this.upsertConfigWithClient(tx, config)
await tx.shareLink.update({
where: { id: shareLinkId },
data: {
watermarkConfigId: watermarkConfig.id,
watermarkStatus: WatermarkStatus.processing,
},
})
// Dispatch transcode tasks for all video/image assets in the sharelink
await this.triggerWatermarkTranscodeForShareLink(shareLinkId, watermarkConfig.id, tx)
return await shareService.getShareLink(shareLinkId, tx)
})
}
async getShareLinkWatermark(shareLinkId: string): Promise<{
watermarkStatus: WatermarkStatus
watermarkConfig: WatermarkConfigInfo | null
}> {
const shareLink = await this.prismaClient.shareLink.findUnique({
where: { id: shareLinkId },
include: { watermarkConfig: true },
})
if (!shareLink) {
throw new ShareLinkNotFoundError('Share link not found')
}
return {
watermarkStatus: shareLink.watermarkStatus,
watermarkConfig: shareLink.watermarkConfig
? await this.toWatermarkConfigInfo(shareLink.watermarkConfig)
: null,
}
}
/**
* Finds all media file asset IDs (videos and images) contained in the sharelink,
* including files within symlinked folders, and enqueues transcode workflow tasks.
*/
async triggerWatermarkTranscodeForShareLink(
shareLinkId: string,
watermarkConfigId: string,
txClient?: WatermarkDbClient,
): Promise<number> {
const client = txClient || this.prismaClient
const shareLink = await client.shareLink.findUnique({
where: { id: shareLinkId },
})
if (!shareLink) return 0
const targetMediaAssets = await this.getMediaAssetIdsInShareLink(shareLink.rootFolderId, client)
if (targetMediaAssets.length === 0) {
// If no media assets in sharelink, mark sharelink watermark as ready immediately
await client.shareLink.update({
where: { id: shareLinkId },
data: { watermarkStatus: WatermarkStatus.ready },
})
return 0
}
let dispatchedCount = 0
for (const assetId of targetMediaAssets) {
// Deliberately one create() per task: the @shumai/db client extension that
// submits tasks to the workflow engine only hooks `workflowTask.create`,
// not `createMany`.
await client.workflowTask.create({
data: {
assetId,
type: WorkflowTaskType.transcode_watermark,
status: WorkflowTaskStatus.pending,
projectId: shareLink.projectId,
payload: {
projectId: shareLink.projectId,
watermark: {
watermarkConfigId,
shareLinkId,
},
},
},
})
dispatchedCount++
}
return dispatchedCount
}
/**
* Recursively resolves real media file asset IDs (video and image) under a sharelink root folder.
* Walks the tree level-by-level (batched queries) and follows symlinks at any depth.
*/
async getMediaAssetIdsInShareLink(
rootFolderId: string,
txClient?: WatermarkDbClient,
): Promise<string[]> {
const client = txClient || this.prismaClient
// Fetch symlinks directly under root folder; these point to the shared targets
const symlinks = await client.asset.findMany({
where: {
parentId: rootFolderId,
type: 'symlink',
isDeleted: false,
},
select: { targetId: true },
})
const queue = symlinks.map((s) => s.targetId).filter((id): id is string => !!id)
if (queue.length === 0) return []
const mediaAssetIds: string[] = []
const visited = new Set<string>()
while (queue.length > 0) {
const frontier = queue.splice(0)
const assets = await client.asset.findMany({
where: { id: { in: frontier } },
select: {
id: true,
type: true,
mediaType: true,
media: true,
isDeleted: true,
targetId: true,
},
})
const folderIds: string[] = []
const next: string[] = []
for (const asset of assets) {
if (visited.has(asset.id)) continue
visited.add(asset.id)
if (asset.isDeleted) continue
if (asset.type === 'file') {
const mediaInfo = asset.media as PrismaJson.MediaInfo | null
const proxyType = mediaInfo?.proxyType
const isVideo = proxyType === 'video' || asset.mediaType?.startsWith('video/')
const isImage = proxyType === 'image' || asset.mediaType?.startsWith('image/')
if (isVideo || isImage) {
mediaAssetIds.push(asset.id)
}
} else if (asset.type === 'folder') {
folderIds.push(asset.id)
} else if (asset.type === 'symlink' && asset.targetId) {
// Resolve nested symlinks (e.g. folders that contain their own symlinks)
next.push(asset.targetId)
}
}
if (folderIds.length > 0) {
const children = await client.asset.findMany({
where: { parentId: { in: folderIds }, isDeleted: false },
select: { id: true },
})
next.push(...children.map((c) => c.id))
}
queue.push(...next)
}
return mediaAssetIds
}
/**
* Checks if all required media assets in a sharelink have completed watermark transcodes.
* If all are completed, sets ShareLink.watermarkStatus to 'ready'.
* If any failed, sets ShareLink.watermarkStatus to 'failed'.
*/
async checkAndUpdateShareLinkStatus(shareLinkId: string): Promise<WatermarkStatus> {
const shareLink = await this.prismaClient.shareLink.findUnique({
where: { id: shareLinkId },
})
if (!shareLink || !shareLink.watermarkConfigId) {
return WatermarkStatus.disabled
}
const watermarkConfigId = shareLink.watermarkConfigId
const mediaAssetIds = await this.getMediaAssetIdsInShareLink(shareLink.rootFolderId)
if (mediaAssetIds.length === 0) {
await this.prismaClient.shareLink.update({
where: { id: shareLinkId },
data: { watermarkStatus: WatermarkStatus.ready },
})
return WatermarkStatus.ready
}
const watermarkFiles = await this.prismaClient.watermarkFile.findMany({
where: {
assetId: { in: mediaAssetIds },
watermarkConfigId,
},
})
const statusMap = new Map(watermarkFiles.map((wf) => [wf.assetId, wf.status]))
let allCompleted = true
let anyFailed = false
for (const assetId of mediaAssetIds) {
const status = statusMap.get(assetId)
if (status === WatermarkFileStatus.failed) {
anyFailed = true
allCompleted = false
break
}
if (status !== WatermarkFileStatus.completed) {
allCompleted = false
}
}
let newStatus: WatermarkStatus
if (anyFailed) {
newStatus = WatermarkStatus.failed
} else if (allCompleted) {
newStatus = WatermarkStatus.ready
} else {
newStatus = WatermarkStatus.processing
}
if (newStatus !== shareLink.watermarkStatus) {
await this.prismaClient.shareLink.update({
where: { id: shareLinkId },
data: { watermarkStatus: newStatus },
})
}
return newStatus
}
// ----------------------------------------------------------------------
// Background Async Garbage Collection
// ----------------------------------------------------------------------
/**
* Background task to prune orphan WatermarkConfig records and delete their storage files.
* Runs as part of background cleanup.
*/
async purgeOrphanWatermarkConfigs(): Promise<number> {
const bucket = process.env.S3_BUCKET || 'shumai'
// 1. Find orphan configs with 0 sharelinks attached and no in-flight watermark
// tasks, using FOR UPDATE SKIP LOCKED. Configs with pending/processing tasks
// must not be purged, or the running activities would fail with FK violations.
const orphanConfigs = await this.prismaClient.$queryRaw<{ id: string }[]>`
SELECT wc.id FROM watermark_configs wc
WHERE NOT EXISTS (SELECT 1 FROM share_links sl WHERE sl.watermark_config_id = wc.id)
AND NOT EXISTS (
SELECT 1 FROM workflow_tasks wt
WHERE wt.type = 'transcode_watermark'
AND wt.status IN ('pending', 'processing')
AND wt.payload->'watermark'->>'watermarkConfigId' = wc.id
)
LIMIT 20
FOR UPDATE SKIP LOCKED
`
if (orphanConfigs.length === 0) return 0
let purgedCount = 0
for (const config of orphanConfigs) {
try {
// Fetch all watermark files for this config
const watermarkFiles = await this.prismaClient.watermarkFile.findMany({
where: { watermarkConfigId: config.id },
})
// Delete proxy files from S3
for (const wf of watermarkFiles) {
const media = wf.media
if (media) {
const keysToDelete: string[] = []
if (Array.isArray(media.videoTranscodes)) {
for (const vt of media.videoTranscodes) {
if (vt.key) keysToDelete.push(vt.key)
}
}
if (Array.isArray(media.imageTranscodes)) {
for (const it of media.imageTranscodes) {
if (it.key) keysToDelete.push(it.key)
}
}
if (media.videoPreview?.key) keysToDelete.push(media.videoPreview.key)
if (media.thumbnail?.key) keysToDelete.push(media.thumbnail.key)
for (const key of keysToDelete) {
try {
await s3Service.deleteObject(bucket, key)
} catch (s3Err) {
logger.warn({ key, err: s3Err }, 'Failed to delete watermark proxy file from S3')
}
}
}
}
// Delete WatermarkFiles and WatermarkConfig in DB
await this.prismaClient.$transaction(async (tx) => {
await tx.watermarkFile.deleteMany({
where: { watermarkConfigId: config.id },
})
await tx.watermarkConfig.delete({
where: { id: config.id },
})
})
purgedCount++
logger.info({ configId: config.id }, 'Purged orphan watermark config and proxy files')
} catch (err) {
logger.error({ configId: config.id, err }, 'Failed to purge orphan watermark config')
}
}
return purgedCount
}
/**
* Fetches completed watermark media entries for a list of asset IDs under a specific watermark config.
* Returns a map of assetId -> PrismaJson.MediaInfo.
*/
async getCompletedWatermarkMediaMap(
assetIds: string[],
watermarkConfigId: string,
): Promise<Map<string, PrismaJson.MediaInfo>> {
if (assetIds.length === 0) return new Map()
const watermarkFiles = await prisma.watermarkFile.findMany({
where: {
assetId: { in: assetIds },
watermarkConfigId,
status: 'completed',
},
})
const map = new Map<string, PrismaJson.MediaInfo>()
for (const wf of watermarkFiles) {
if (wf.media) {
map.set(wf.assetId, wf.media as PrismaJson.MediaInfo)
}
}
return map
}
/**
* Enriches image blocks in a watermark config with accessible presigned URLs for WebUI rendering.
*/
async enrichWatermarkConfigWithPresignedUrls(
config: WatermarkConfigSpec,
): Promise<WatermarkConfigSpec> {
if (!config || !config.blocks || config.blocks.length === 0) return config
const bucket = process.env.S3_BUCKET || 'shumai'
const enrichedBlocks = await Promise.all(
config.blocks.map(async (block) => {
if (block.type === 'image' && block.imageAssetKey) {
try {
const url = await s3Service.presign(bucket, block.imageAssetKey, 'GET')
return { ...block, imageAssetUrl: url }
} catch (err) {
logger.warn({ key: block.imageAssetKey, err }, 'Failed to presign watermark image key')
}
}
return block
}),
)
return { ...config, blocks: enrichedBlocks }
}
// ----------------------------------------------------------------------
// DTO Mappers
// ----------------------------------------------------------------------
private async toWatermarkTemplateInfo(t: WatermarkTemplate): Promise<WatermarkTemplateInfo> {
const config = await this.enrichWatermarkConfigWithPresignedUrls(
t.config as WatermarkConfigSpec,
)
return {
id: t.id,
name: t.name,
config,
teamId: t.teamId,
createdAt: t.createdAt.toISOString(),
updatedAt: t.updatedAt.toISOString(),
}
}
private async toWatermarkConfigInfo(c: WatermarkConfig): Promise<WatermarkConfigInfo> {
const config = await this.enrichWatermarkConfigWithPresignedUrls(
c.config as WatermarkConfigSpec,
)
return {
id: c.id,
config,
hash: c.hash,
createdAt: c.createdAt.toISOString(),
updatedAt: c.updatedAt.toISOString(),
}
}
}
export const watermarkService = new WatermarkService()
+1 -1
View File
@@ -1,6 +1,6 @@
{
"name": "@shumai/db",
"version": "0.3.3",
"version": "0.3.6",
"private": true,
"type": "module",
"main": "./src/index.ts",
@@ -0,0 +1,69 @@
-- CreateEnum
CREATE TYPE "WatermarkStatus" AS ENUM ('disabled', 'processing', 'ready', 'failed');
-- AlterEnum
ALTER TYPE "WorkflowTaskType" ADD VALUE 'transcode_watermark';
-- AlterTable
ALTER TABLE "share_links" ADD COLUMN "watermark_config_id" TEXT,
ADD COLUMN "watermark_status" "WatermarkStatus" NOT NULL DEFAULT 'disabled';
-- CreateTable
CREATE TABLE "watermark_configs" (
"id" TEXT NOT NULL,
"config" JSONB NOT NULL,
"hash" TEXT NOT NULL,
"created_at" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
"updated_at" TIMESTAMP(3) NOT NULL,
CONSTRAINT "watermark_configs_pkey" PRIMARY KEY ("id")
);
-- CreateTable
CREATE TABLE "watermark_templates" (
"id" TEXT NOT NULL,
"name" TEXT NOT NULL,
"config" JSONB NOT NULL,
"team_id" TEXT,
"created_at" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
"updated_at" TIMESTAMP(3) NOT NULL,
CONSTRAINT "watermark_templates_pkey" PRIMARY KEY ("id")
);
-- CreateTable
CREATE TABLE "watermark_files" (
"id" TEXT NOT NULL,
"asset_id" TEXT NOT NULL,
"watermark_config_id" TEXT NOT NULL,
"media" JSONB,
"status" "WorkflowTaskStatus" NOT NULL DEFAULT 'pending',
"created_at" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
"updated_at" TIMESTAMP(3) NOT NULL,
CONSTRAINT "watermark_files_pkey" PRIMARY KEY ("id")
);
-- CreateIndex
CREATE UNIQUE INDEX "watermark_configs_hash_key" ON "watermark_configs"("hash");
-- CreateIndex
CREATE INDEX "watermark_templates_team_id_idx" ON "watermark_templates"("team_id");
-- CreateIndex
CREATE INDEX "watermark_files_watermark_config_id_idx" ON "watermark_files"("watermark_config_id");
-- CreateIndex
CREATE UNIQUE INDEX "watermark_files_asset_id_watermark_config_id_key" ON "watermark_files"("asset_id", "watermark_config_id");
-- AddForeignKey
ALTER TABLE "share_links" ADD CONSTRAINT "share_links_watermark_config_id_fkey" FOREIGN KEY ("watermark_config_id") REFERENCES "watermark_configs"("id") ON DELETE SET NULL ON UPDATE CASCADE;
-- AddForeignKey
ALTER TABLE "watermark_templates" ADD CONSTRAINT "watermark_templates_team_id_fkey" FOREIGN KEY ("team_id") REFERENCES "teams"("id") ON DELETE CASCADE ON UPDATE CASCADE;
-- AddForeignKey
ALTER TABLE "watermark_files" ADD CONSTRAINT "watermark_files_asset_id_fkey" FOREIGN KEY ("asset_id") REFERENCES "assets"("id") ON DELETE CASCADE ON UPDATE CASCADE;
-- AddForeignKey
ALTER TABLE "watermark_files" ADD CONSTRAINT "watermark_files_watermark_config_id_fkey" FOREIGN KEY ("watermark_config_id") REFERENCES "watermark_configs"("id") ON DELETE CASCADE ON UPDATE CASCADE;
@@ -0,0 +1,7 @@
-- CreateEnum
CREATE TYPE "WatermarkFileStatus" AS ENUM ('pending', 'processing', 'completed', 'failed');
-- AlterTable
ALTER TABLE "watermark_files" ALTER COLUMN "status" DROP DEFAULT;
ALTER TABLE "watermark_files" ALTER COLUMN "status" TYPE "WatermarkFileStatus" USING ("status"::text::"WatermarkFileStatus");
ALTER TABLE "watermark_files" ALTER COLUMN "status" SET DEFAULT 'pending';
@@ -0,0 +1,86 @@
-- Data cleanup: remove legacy media JSON fields that are no longer used.
--
-- WebUI now displays transcoded proxies only and never falls back to the raw
-- original file:
-- 1. Drop the raw-original marker entries (`isRaw: true`) from
-- videoTranscodes / imageTranscodes. They pointed at the original file
-- key and were only consumed by the removed display fallbacks and the
-- download-menu entries, which now use media.original.key directly.
-- 2. Strip the now-removed `isRaw` field from remaining transcode entries.
-- 3. Drop `original.downloadUrl` (removed from the AssetInfo DTO; downloads
-- resolve a fresh presigned URL from `key` via the download-url APIs).
UPDATE "assets"
SET "media" = jsonb_set(
jsonb_set(
CASE WHEN jsonb_typeof("media"->'original') = 'object'
THEN "media" #- '{original,downloadUrl}'
ELSE "media" END,
'{videoTranscodes}',
COALESCE(
(SELECT jsonb_agg(elem - 'isRaw')
FROM jsonb_array_elements("media"->'videoTranscodes') elem
WHERE jsonb_typeof(elem) = 'object'
AND NOT COALESCE((elem->>'isRaw')::boolean, false)),
'[]'::jsonb
)
),
'{imageTranscodes}',
COALESCE(
(SELECT jsonb_agg(elem - 'isRaw')
FROM jsonb_array_elements("media"->'imageTranscodes') elem
WHERE jsonb_typeof(elem) = 'object'
AND NOT COALESCE((elem->>'isRaw')::boolean, false)),
'[]'::jsonb
)
)
WHERE "media" IS NOT NULL
AND (
(jsonb_typeof("media"->'original') = 'object' AND "media"->'original' ? 'downloadUrl')
OR EXISTS (
SELECT 1 FROM jsonb_array_elements(COALESCE("media"->'videoTranscodes', '[]'::jsonb)) e
WHERE jsonb_typeof(e) = 'object' AND e ? 'isRaw'
)
OR EXISTS (
SELECT 1 FROM jsonb_array_elements(COALESCE("media"->'imageTranscodes', '[]'::jsonb)) e
WHERE jsonb_typeof(e) = 'object' AND e ? 'isRaw'
)
);
-- Same cleanup for watermarked proxy media.
UPDATE "watermark_files"
SET "media" = jsonb_set(
jsonb_set(
CASE WHEN jsonb_typeof("media"->'original') = 'object'
THEN "media" #- '{original,downloadUrl}'
ELSE "media" END,
'{videoTranscodes}',
COALESCE(
(SELECT jsonb_agg(elem - 'isRaw')
FROM jsonb_array_elements("media"->'videoTranscodes') elem
WHERE jsonb_typeof(elem) = 'object'
AND NOT COALESCE((elem->>'isRaw')::boolean, false)),
'[]'::jsonb
)
),
'{imageTranscodes}',
COALESCE(
(SELECT jsonb_agg(elem - 'isRaw')
FROM jsonb_array_elements("media"->'imageTranscodes') elem
WHERE jsonb_typeof(elem) = 'object'
AND NOT COALESCE((elem->>'isRaw')::boolean, false)),
'[]'::jsonb
)
)
WHERE "media" IS NOT NULL
AND (
(jsonb_typeof("media"->'original') = 'object' AND "media"->'original' ? 'downloadUrl')
OR EXISTS (
SELECT 1 FROM jsonb_array_elements(COALESCE("media"->'videoTranscodes', '[]'::jsonb)) e
WHERE jsonb_typeof(e) = 'object' AND e ? 'isRaw'
)
OR EXISTS (
SELECT 1 FROM jsonb_array_elements(COALESCE("media"->'imageTranscodes', '[]'::jsonb)) e
WHERE jsonb_typeof(e) = 'object' AND e ? 'isRaw'
)
);
@@ -0,0 +1,2 @@
-- AlterTable
ALTER TABLE "share_links" ADD COLUMN "allow_download" BOOLEAN NOT NULL DEFAULT true;
@@ -0,0 +1,71 @@
-- CreateEnum
CREATE TYPE "McpTransport" AS ENUM ('streamable_http', 'sse');
-- CreateTable
CREATE TABLE "mcp_servers" (
"id" TEXT NOT NULL,
"name" TEXT NOT NULL,
"url" TEXT NOT NULL,
"transport" "McpTransport" NOT NULL DEFAULT 'streamable_http',
"authConfig" JSONB DEFAULT '{}',
"config" JSONB DEFAULT '{}',
"enabled" BOOLEAN NOT NULL DEFAULT true,
"permission" "TeamMemberRole" NOT NULL DEFAULT 'reviewer',
"tools" JSONB DEFAULT '[]',
"status" TEXT NOT NULL DEFAULT 'not_connected',
"last_error" TEXT,
"last_connected_at" TIMESTAMP(3),
"created_at" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
"updated_at" TIMESTAMP(3) NOT NULL,
"team_id" TEXT NOT NULL,
CONSTRAINT "mcp_servers_pkey" PRIMARY KEY ("id")
);
-- CreateTable
CREATE TABLE "agent_mcp_servers" (
"id" TEXT NOT NULL,
"agent_id" TEXT NOT NULL,
"mcp_server_id" TEXT NOT NULL,
"created_at" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
"updated_at" TIMESTAMP(3) NOT NULL,
CONSTRAINT "agent_mcp_servers_pkey" PRIMARY KEY ("id")
);
-- CreateTable
CREATE TABLE "mcp_server_credentials" (
"id" TEXT NOT NULL,
"server_id" TEXT NOT NULL,
"server_url" TEXT NOT NULL,
"tokens" JSONB,
"clientInfo" JSONB,
"code_verifier" TEXT,
"oauth_state" TEXT,
"pending_auth" JSONB,
"created_at" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
"updated_at" TIMESTAMP(3) NOT NULL,
CONSTRAINT "mcp_server_credentials_pkey" PRIMARY KEY ("id")
);
-- CreateIndex
CREATE UNIQUE INDEX "mcp_servers_team_id_name_key" ON "mcp_servers"("team_id", "name");
-- CreateIndex
CREATE UNIQUE INDEX "agent_mcp_servers_agent_id_mcp_server_id_key" ON "agent_mcp_servers"("agent_id", "mcp_server_id");
-- CreateIndex
CREATE UNIQUE INDEX "mcp_server_credentials_server_id_key" ON "mcp_server_credentials"("server_id");
-- AddForeignKey
ALTER TABLE "mcp_servers" ADD CONSTRAINT "mcp_servers_team_id_fkey" FOREIGN KEY ("team_id") REFERENCES "teams"("id") ON DELETE CASCADE ON UPDATE CASCADE;
-- AddForeignKey
ALTER TABLE "agent_mcp_servers" ADD CONSTRAINT "agent_mcp_servers_agent_id_fkey" FOREIGN KEY ("agent_id") REFERENCES "agents"("id") ON DELETE CASCADE ON UPDATE CASCADE;
-- AddForeignKey
ALTER TABLE "agent_mcp_servers" ADD CONSTRAINT "agent_mcp_servers_mcp_server_id_fkey" FOREIGN KEY ("mcp_server_id") REFERENCES "mcp_servers"("id") ON DELETE CASCADE ON UPDATE CASCADE;
-- AddForeignKey
ALTER TABLE "mcp_server_credentials" ADD CONSTRAINT "mcp_server_credentials_server_id_fkey" FOREIGN KEY ("server_id") REFERENCES "mcp_servers"("id") ON DELETE CASCADE ON UPDATE CASCADE;
@@ -0,0 +1,12 @@
/*
Warnings:
- You are about to drop the column `enabled` on the `mcp_servers` table. All the data in the column will be lost.
*/
-- DropIndex
DROP INDEX "mcp_servers_team_id_name_key";
-- AlterTable
ALTER TABLE "mcp_servers" DROP COLUMN "enabled",
ADD COLUMN "description" TEXT;
@@ -0,0 +1,2 @@
-- AlterTable
ALTER TABLE "mcp_servers" ADD COLUMN "instructions" TEXT;
+137
View File
@@ -106,6 +106,7 @@ enum WorkflowTaskType {
transcode_pdf_pages
transcode_screenshot
transcode_image_annotation
transcode_watermark
ai_metadata_autofill
chat
ai_embedding
@@ -120,6 +121,20 @@ enum WorkflowTaskStatus {
failed
}
enum WatermarkStatus {
disabled
processing
ready
failed
}
enum WatermarkFileStatus {
pending
processing
completed
failed
}
// ----------------------------------------------------------------------
// Models
// ----------------------------------------------------------------------
@@ -237,10 +252,12 @@ model Team {
userMetadata UserMetadata[] @relation("TeamToUserMetadata")
providers Provider[] @relation("TeamToProvider")
skills Skill[] @relation("TeamToSkill")
mcpServers McpServer[] @relation("TeamToMcpServer")
sandbox Sandbox? @relation("TeamToSandbox")
agents Agent[] @relation("TeamToAgent")
aiUsages AiUsage[] @relation("TeamToAiUsage")
auditLogs AuditLog[] @relation("TeamToAuditLog")
watermarkTemplates WatermarkTemplate[] @relation("TeamToWatermarkTemplate")
@@map("teams")
}
@@ -351,6 +368,7 @@ model ShareLink {
expireAt DateTime? @map("expire_at")
password String?
isDisabled Boolean @default(false) @map("is_disabled")
allowDownload Boolean @default(true) @map("allow_download")
defaultSortOrder String? @map("default_sort_order")
viewMode String? @map("view_mode")
/// [ShareLinkFieldVisibility]
@@ -367,9 +385,59 @@ model ShareLink {
creatorId String? @map("creator_id")
creator User? @relation("UserToShareLink", fields: [creatorId], references: [id])
watermarkConfigId String? @map("watermark_config_id")
watermarkStatus WatermarkStatus @default(disabled) @map("watermark_status")
watermarkConfig WatermarkConfig? @relation(fields: [watermarkConfigId], references: [id], onDelete: SetNull)
@@map("share_links")
}
model WatermarkConfig {
id String @id @default(ulid())
/// [WatermarkConfigSpec]
config Json
hash String @unique
createdAt DateTime @default(now()) @map("created_at")
updatedAt DateTime @updatedAt @map("updated_at")
shareLinks ShareLink[]
watermarkFiles WatermarkFile[]
@@map("watermark_configs")
}
model WatermarkTemplate {
id String @id @default(ulid())
name String
/// [WatermarkConfigSpec]
config Json
teamId String? @map("team_id")
team Team? @relation("TeamToWatermarkTemplate", fields: [teamId], references: [id], onDelete: Cascade)
createdAt DateTime @default(now()) @map("created_at")
updatedAt DateTime @updatedAt @map("updated_at")
@@index([teamId])
@@map("watermark_templates")
}
model WatermarkFile {
id String @id @default(ulid())
assetId String @map("asset_id")
watermarkConfigId String @map("watermark_config_id")
/// [MediaInfo]
media Json?
status WatermarkFileStatus @default(pending)
createdAt DateTime @default(now()) @map("created_at")
updatedAt DateTime @updatedAt @map("updated_at")
asset Asset @relation("AssetToWatermarkFile", fields: [assetId], references: [id], onDelete: Cascade)
watermarkConfig WatermarkConfig @relation(fields: [watermarkConfigId], references: [id], onDelete: Cascade)
@@unique([assetId, watermarkConfigId])
@@index([watermarkConfigId])
@@map("watermark_files")
}
model Asset {
id String @id @default(ulid())
name String @default("")
@@ -421,6 +489,7 @@ model Asset {
projectShareRoot Project? @relation("ProjectToShareRoot")
shareLinkRootFolder ShareLink? @relation("ShareLinkToRootFolder")
agentSessions AgentSession[] @relation("AssetToAgentSession")
watermarkFiles WatermarkFile[] @relation("AssetToWatermarkFile")
@@map("assets")
@@index([type])
@@ -686,6 +755,7 @@ model Agent {
updatedAt DateTime @updatedAt @map("updated_at")
agentSessions AgentSession[]
skills AgentSkill[]
mcpServers AgentMcpServer[]
@@map("agents")
}
@@ -703,6 +773,73 @@ model AgentSkill {
@@map("agent_skills")
}
model McpServer {
id String @id @default(ulid())
name String
description String?
instructions String?
url String
transport McpTransport @default(streamable_http)
/// [McpServerAuthConfig]
authConfig Json? @default("{}")
/// [McpServerConfig]
config Json? @default("{}")
permission TeamMemberRole @default(reviewer)
/// [McpToolInfo[]]
tools Json? @default("[]")
status String @default("not_connected")
lastError String? @map("last_error")
lastConnectedAt DateTime? @map("last_connected_at")
createdAt DateTime @default(now()) @map("created_at")
updatedAt DateTime @updatedAt @map("updated_at")
teamId String @map("team_id")
team Team @relation("TeamToMcpServer", fields: [teamId], references: [id], onDelete: Cascade)
credential McpServerCredential?
agentMcpServers AgentMcpServer[]
@@map("mcp_servers")
}
// Join table: which agents get which MCP servers (mirrors AgentSkill).
model AgentMcpServer {
id String @id @default(ulid())
agentId String @map("agent_id")
agent Agent @relation(fields: [agentId], references: [id], onDelete: Cascade)
mcpServerId String @map("mcp_server_id")
mcpServer McpServer @relation(fields: [mcpServerId], references: [id], onDelete: Cascade)
createdAt DateTime @default(now()) @map("created_at")
updatedAt DateTime @updatedAt @map("updated_at")
@@unique([agentId, mcpServerId])
@@map("agent_mcp_servers")
}
model McpServerCredential {
id String @id @default(ulid())
serverId String @unique @map("server_id")
server McpServer @relation(fields: [serverId], references: [id], onDelete: Cascade)
serverUrl String @map("server_url")
/// [McpStoredTokens]
tokens Json?
/// [McpStoredClientInfo]
clientInfo Json?
codeVerifier String? @map("code_verifier")
oauthState String? @map("oauth_state")
/// [McpPendingAuth]
pendingAuth Json? @map("pending_auth")
createdAt DateTime @default(now()) @map("created_at")
updatedAt DateTime @updatedAt @map("updated_at")
@@map("mcp_server_credentials")
}
enum McpTransport {
streamable_http
sse
}
model AgentSession {
id String @id @default(ulid())
agentId String @map("agent_id")
+30
View File
@@ -77,6 +77,21 @@ export type ProjectMember = Prisma.ProjectMemberModel
*
*/
export type ShareLink = Prisma.ShareLinkModel
/**
* Model WatermarkConfig
*
*/
export type WatermarkConfig = Prisma.WatermarkConfigModel
/**
* Model WatermarkTemplate
*
*/
export type WatermarkTemplate = Prisma.WatermarkTemplateModel
/**
* Model WatermarkFile
*
*/
export type WatermarkFile = Prisma.WatermarkFileModel
/**
* Model Asset
*
@@ -147,6 +162,21 @@ export type Agent = Prisma.AgentModel
*
*/
export type AgentSkill = Prisma.AgentSkillModel
/**
* Model McpServer
*
*/
export type McpServer = Prisma.McpServerModel
/**
* Model AgentMcpServer
*
*/
export type AgentMcpServer = Prisma.AgentMcpServerModel
/**
* Model McpServerCredential
*
*/
export type McpServerCredential = Prisma.McpServerCredentialModel
/**
* Model AgentSession
*
+30
View File
@@ -101,6 +101,21 @@ export type ProjectMember = Prisma.ProjectMemberModel
*
*/
export type ShareLink = Prisma.ShareLinkModel
/**
* Model WatermarkConfig
*
*/
export type WatermarkConfig = Prisma.WatermarkConfigModel
/**
* Model WatermarkTemplate
*
*/
export type WatermarkTemplate = Prisma.WatermarkTemplateModel
/**
* Model WatermarkFile
*
*/
export type WatermarkFile = Prisma.WatermarkFileModel
/**
* Model Asset
*
@@ -171,6 +186,21 @@ export type Agent = Prisma.AgentModel
*
*/
export type AgentSkill = Prisma.AgentSkillModel
/**
* Model McpServer
*
*/
export type McpServer = Prisma.McpServerModel
/**
* Model AgentMcpServer
*
*/
export type AgentMcpServer = Prisma.AgentMcpServerModel
/**
* Model McpServerCredential
*
*/
export type McpServerCredential = Prisma.McpServerCredentialModel
/**
* Model AgentSession
*
+170 -68
View File
@@ -267,6 +267,91 @@ export type EnumProjectMemberRoleWithAggregatesFilter<$PrismaModel = never> = {
_max?: Prisma.NestedEnumProjectMemberRoleFilter<$PrismaModel>
}
export type EnumWatermarkStatusFilter<$PrismaModel = never> = {
equals?: $Enums.WatermarkStatus | Prisma.EnumWatermarkStatusFieldRefInput<$PrismaModel>
in?: $Enums.WatermarkStatus[] | Prisma.ListEnumWatermarkStatusFieldRefInput<$PrismaModel>
notIn?: $Enums.WatermarkStatus[] | Prisma.ListEnumWatermarkStatusFieldRefInput<$PrismaModel>
not?: Prisma.NestedEnumWatermarkStatusFilter<$PrismaModel> | $Enums.WatermarkStatus
}
export type EnumWatermarkStatusWithAggregatesFilter<$PrismaModel = never> = {
equals?: $Enums.WatermarkStatus | Prisma.EnumWatermarkStatusFieldRefInput<$PrismaModel>
in?: $Enums.WatermarkStatus[] | Prisma.ListEnumWatermarkStatusFieldRefInput<$PrismaModel>
notIn?: $Enums.WatermarkStatus[] | Prisma.ListEnumWatermarkStatusFieldRefInput<$PrismaModel>
not?: Prisma.NestedEnumWatermarkStatusWithAggregatesFilter<$PrismaModel> | $Enums.WatermarkStatus
_count?: Prisma.NestedIntFilter<$PrismaModel>
_min?: Prisma.NestedEnumWatermarkStatusFilter<$PrismaModel>
_max?: Prisma.NestedEnumWatermarkStatusFilter<$PrismaModel>
}
export type JsonFilter<$PrismaModel = never> =
| Prisma.PatchUndefined<
Prisma.Either<Required<JsonFilterBase<$PrismaModel>>, Exclude<keyof Required<JsonFilterBase<$PrismaModel>>, 'path'>>,
Required<JsonFilterBase<$PrismaModel>>
>
| Prisma.OptionalFlat<Omit<Required<JsonFilterBase<$PrismaModel>>, 'path'>>
export type JsonFilterBase<$PrismaModel = never> = {
equals?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | Prisma.JsonNullValueFilter
path?: string[]
mode?: Prisma.QueryMode | Prisma.EnumQueryModeFieldRefInput<$PrismaModel>
string_contains?: string | Prisma.StringFieldRefInput<$PrismaModel>
string_starts_with?: string | Prisma.StringFieldRefInput<$PrismaModel>
string_ends_with?: string | Prisma.StringFieldRefInput<$PrismaModel>
array_starts_with?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | null
array_ends_with?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | null
array_contains?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | null
lt?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel>
lte?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel>
gt?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel>
gte?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel>
not?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | Prisma.JsonNullValueFilter
}
export type JsonWithAggregatesFilter<$PrismaModel = never> =
| Prisma.PatchUndefined<
Prisma.Either<Required<JsonWithAggregatesFilterBase<$PrismaModel>>, Exclude<keyof Required<JsonWithAggregatesFilterBase<$PrismaModel>>, 'path'>>,
Required<JsonWithAggregatesFilterBase<$PrismaModel>>
>
| Prisma.OptionalFlat<Omit<Required<JsonWithAggregatesFilterBase<$PrismaModel>>, 'path'>>
export type JsonWithAggregatesFilterBase<$PrismaModel = never> = {
equals?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | Prisma.JsonNullValueFilter
path?: string[]
mode?: Prisma.QueryMode | Prisma.EnumQueryModeFieldRefInput<$PrismaModel>
string_contains?: string | Prisma.StringFieldRefInput<$PrismaModel>
string_starts_with?: string | Prisma.StringFieldRefInput<$PrismaModel>
string_ends_with?: string | Prisma.StringFieldRefInput<$PrismaModel>
array_starts_with?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | null
array_ends_with?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | null
array_contains?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | null
lt?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel>
lte?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel>
gt?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel>
gte?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel>
not?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | Prisma.JsonNullValueFilter
_count?: Prisma.NestedIntFilter<$PrismaModel>
_min?: Prisma.NestedJsonFilter<$PrismaModel>
_max?: Prisma.NestedJsonFilter<$PrismaModel>
}
export type EnumWatermarkFileStatusFilter<$PrismaModel = never> = {
equals?: $Enums.WatermarkFileStatus | Prisma.EnumWatermarkFileStatusFieldRefInput<$PrismaModel>
in?: $Enums.WatermarkFileStatus[] | Prisma.ListEnumWatermarkFileStatusFieldRefInput<$PrismaModel>
notIn?: $Enums.WatermarkFileStatus[] | Prisma.ListEnumWatermarkFileStatusFieldRefInput<$PrismaModel>
not?: Prisma.NestedEnumWatermarkFileStatusFilter<$PrismaModel> | $Enums.WatermarkFileStatus
}
export type EnumWatermarkFileStatusWithAggregatesFilter<$PrismaModel = never> = {
equals?: $Enums.WatermarkFileStatus | Prisma.EnumWatermarkFileStatusFieldRefInput<$PrismaModel>
in?: $Enums.WatermarkFileStatus[] | Prisma.ListEnumWatermarkFileStatusFieldRefInput<$PrismaModel>
notIn?: $Enums.WatermarkFileStatus[] | Prisma.ListEnumWatermarkFileStatusFieldRefInput<$PrismaModel>
not?: Prisma.NestedEnumWatermarkFileStatusWithAggregatesFilter<$PrismaModel> | $Enums.WatermarkFileStatus
_count?: Prisma.NestedIntFilter<$PrismaModel>
_min?: Prisma.NestedEnumWatermarkFileStatusFilter<$PrismaModel>
_max?: Prisma.NestedEnumWatermarkFileStatusFilter<$PrismaModel>
}
export type EnumAssetTypeFilter<$PrismaModel = never> = {
equals?: $Enums.AssetType | Prisma.EnumAssetTypeFieldRefInput<$PrismaModel>
in?: $Enums.AssetType[] | Prisma.ListEnumAssetTypeFieldRefInput<$PrismaModel>
@@ -592,30 +677,6 @@ export type EnumAgentTypeFilter<$PrismaModel = never> = {
not?: Prisma.NestedEnumAgentTypeFilter<$PrismaModel> | $Enums.AgentType
}
export type JsonFilter<$PrismaModel = never> =
| Prisma.PatchUndefined<
Prisma.Either<Required<JsonFilterBase<$PrismaModel>>, Exclude<keyof Required<JsonFilterBase<$PrismaModel>>, 'path'>>,
Required<JsonFilterBase<$PrismaModel>>
>
| Prisma.OptionalFlat<Omit<Required<JsonFilterBase<$PrismaModel>>, 'path'>>
export type JsonFilterBase<$PrismaModel = never> = {
equals?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | Prisma.JsonNullValueFilter
path?: string[]
mode?: Prisma.QueryMode | Prisma.EnumQueryModeFieldRefInput<$PrismaModel>
string_contains?: string | Prisma.StringFieldRefInput<$PrismaModel>
string_starts_with?: string | Prisma.StringFieldRefInput<$PrismaModel>
string_ends_with?: string | Prisma.StringFieldRefInput<$PrismaModel>
array_starts_with?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | null
array_ends_with?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | null
array_contains?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | null
lt?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel>
lte?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel>
gt?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel>
gte?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel>
not?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | Prisma.JsonNullValueFilter
}
export type EnumAgentTypeWithAggregatesFilter<$PrismaModel = never> = {
equals?: $Enums.AgentType | Prisma.EnumAgentTypeFieldRefInput<$PrismaModel>
in?: $Enums.AgentType[] | Prisma.ListEnumAgentTypeFieldRefInput<$PrismaModel>
@@ -626,31 +687,21 @@ export type EnumAgentTypeWithAggregatesFilter<$PrismaModel = never> = {
_max?: Prisma.NestedEnumAgentTypeFilter<$PrismaModel>
}
export type JsonWithAggregatesFilter<$PrismaModel = never> =
| Prisma.PatchUndefined<
Prisma.Either<Required<JsonWithAggregatesFilterBase<$PrismaModel>>, Exclude<keyof Required<JsonWithAggregatesFilterBase<$PrismaModel>>, 'path'>>,
Required<JsonWithAggregatesFilterBase<$PrismaModel>>
>
| Prisma.OptionalFlat<Omit<Required<JsonWithAggregatesFilterBase<$PrismaModel>>, 'path'>>
export type EnumMcpTransportFilter<$PrismaModel = never> = {
equals?: $Enums.McpTransport | Prisma.EnumMcpTransportFieldRefInput<$PrismaModel>
in?: $Enums.McpTransport[] | Prisma.ListEnumMcpTransportFieldRefInput<$PrismaModel>
notIn?: $Enums.McpTransport[] | Prisma.ListEnumMcpTransportFieldRefInput<$PrismaModel>
not?: Prisma.NestedEnumMcpTransportFilter<$PrismaModel> | $Enums.McpTransport
}
export type JsonWithAggregatesFilterBase<$PrismaModel = never> = {
equals?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | Prisma.JsonNullValueFilter
path?: string[]
mode?: Prisma.QueryMode | Prisma.EnumQueryModeFieldRefInput<$PrismaModel>
string_contains?: string | Prisma.StringFieldRefInput<$PrismaModel>
string_starts_with?: string | Prisma.StringFieldRefInput<$PrismaModel>
string_ends_with?: string | Prisma.StringFieldRefInput<$PrismaModel>
array_starts_with?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | null
array_ends_with?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | null
array_contains?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | null
lt?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel>
lte?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel>
gt?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel>
gte?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel>
not?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | Prisma.JsonNullValueFilter
export type EnumMcpTransportWithAggregatesFilter<$PrismaModel = never> = {
equals?: $Enums.McpTransport | Prisma.EnumMcpTransportFieldRefInput<$PrismaModel>
in?: $Enums.McpTransport[] | Prisma.ListEnumMcpTransportFieldRefInput<$PrismaModel>
notIn?: $Enums.McpTransport[] | Prisma.ListEnumMcpTransportFieldRefInput<$PrismaModel>
not?: Prisma.NestedEnumMcpTransportWithAggregatesFilter<$PrismaModel> | $Enums.McpTransport
_count?: Prisma.NestedIntFilter<$PrismaModel>
_min?: Prisma.NestedJsonFilter<$PrismaModel>
_max?: Prisma.NestedJsonFilter<$PrismaModel>
_min?: Prisma.NestedEnumMcpTransportFilter<$PrismaModel>
_max?: Prisma.NestedEnumMcpTransportFilter<$PrismaModel>
}
export type EnumAgentSessionTypeFilter<$PrismaModel = never> = {
@@ -936,6 +987,64 @@ export type NestedEnumProjectMemberRoleWithAggregatesFilter<$PrismaModel = never
_max?: Prisma.NestedEnumProjectMemberRoleFilter<$PrismaModel>
}
export type NestedEnumWatermarkStatusFilter<$PrismaModel = never> = {
equals?: $Enums.WatermarkStatus | Prisma.EnumWatermarkStatusFieldRefInput<$PrismaModel>
in?: $Enums.WatermarkStatus[] | Prisma.ListEnumWatermarkStatusFieldRefInput<$PrismaModel>
notIn?: $Enums.WatermarkStatus[] | Prisma.ListEnumWatermarkStatusFieldRefInput<$PrismaModel>
not?: Prisma.NestedEnumWatermarkStatusFilter<$PrismaModel> | $Enums.WatermarkStatus
}
export type NestedEnumWatermarkStatusWithAggregatesFilter<$PrismaModel = never> = {
equals?: $Enums.WatermarkStatus | Prisma.EnumWatermarkStatusFieldRefInput<$PrismaModel>
in?: $Enums.WatermarkStatus[] | Prisma.ListEnumWatermarkStatusFieldRefInput<$PrismaModel>
notIn?: $Enums.WatermarkStatus[] | Prisma.ListEnumWatermarkStatusFieldRefInput<$PrismaModel>
not?: Prisma.NestedEnumWatermarkStatusWithAggregatesFilter<$PrismaModel> | $Enums.WatermarkStatus
_count?: Prisma.NestedIntFilter<$PrismaModel>
_min?: Prisma.NestedEnumWatermarkStatusFilter<$PrismaModel>
_max?: Prisma.NestedEnumWatermarkStatusFilter<$PrismaModel>
}
export type NestedJsonFilter<$PrismaModel = never> =
| Prisma.PatchUndefined<
Prisma.Either<Required<NestedJsonFilterBase<$PrismaModel>>, Exclude<keyof Required<NestedJsonFilterBase<$PrismaModel>>, 'path'>>,
Required<NestedJsonFilterBase<$PrismaModel>>
>
| Prisma.OptionalFlat<Omit<Required<NestedJsonFilterBase<$PrismaModel>>, 'path'>>
export type NestedJsonFilterBase<$PrismaModel = never> = {
equals?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | Prisma.JsonNullValueFilter
path?: string[]
mode?: Prisma.QueryMode | Prisma.EnumQueryModeFieldRefInput<$PrismaModel>
string_contains?: string | Prisma.StringFieldRefInput<$PrismaModel>
string_starts_with?: string | Prisma.StringFieldRefInput<$PrismaModel>
string_ends_with?: string | Prisma.StringFieldRefInput<$PrismaModel>
array_starts_with?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | null
array_ends_with?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | null
array_contains?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | null
lt?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel>
lte?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel>
gt?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel>
gte?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel>
not?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | Prisma.JsonNullValueFilter
}
export type NestedEnumWatermarkFileStatusFilter<$PrismaModel = never> = {
equals?: $Enums.WatermarkFileStatus | Prisma.EnumWatermarkFileStatusFieldRefInput<$PrismaModel>
in?: $Enums.WatermarkFileStatus[] | Prisma.ListEnumWatermarkFileStatusFieldRefInput<$PrismaModel>
notIn?: $Enums.WatermarkFileStatus[] | Prisma.ListEnumWatermarkFileStatusFieldRefInput<$PrismaModel>
not?: Prisma.NestedEnumWatermarkFileStatusFilter<$PrismaModel> | $Enums.WatermarkFileStatus
}
export type NestedEnumWatermarkFileStatusWithAggregatesFilter<$PrismaModel = never> = {
equals?: $Enums.WatermarkFileStatus | Prisma.EnumWatermarkFileStatusFieldRefInput<$PrismaModel>
in?: $Enums.WatermarkFileStatus[] | Prisma.ListEnumWatermarkFileStatusFieldRefInput<$PrismaModel>
notIn?: $Enums.WatermarkFileStatus[] | Prisma.ListEnumWatermarkFileStatusFieldRefInput<$PrismaModel>
not?: Prisma.NestedEnumWatermarkFileStatusWithAggregatesFilter<$PrismaModel> | $Enums.WatermarkFileStatus
_count?: Prisma.NestedIntFilter<$PrismaModel>
_min?: Prisma.NestedEnumWatermarkFileStatusFilter<$PrismaModel>
_max?: Prisma.NestedEnumWatermarkFileStatusFilter<$PrismaModel>
}
export type NestedEnumAssetTypeFilter<$PrismaModel = never> = {
equals?: $Enums.AssetType | Prisma.EnumAssetTypeFieldRefInput<$PrismaModel>
in?: $Enums.AssetType[] | Prisma.ListEnumAssetTypeFieldRefInput<$PrismaModel>
@@ -1258,28 +1367,21 @@ export type NestedEnumAgentTypeWithAggregatesFilter<$PrismaModel = never> = {
_max?: Prisma.NestedEnumAgentTypeFilter<$PrismaModel>
}
export type NestedJsonFilter<$PrismaModel = never> =
| Prisma.PatchUndefined<
Prisma.Either<Required<NestedJsonFilterBase<$PrismaModel>>, Exclude<keyof Required<NestedJsonFilterBase<$PrismaModel>>, 'path'>>,
Required<NestedJsonFilterBase<$PrismaModel>>
>
| Prisma.OptionalFlat<Omit<Required<NestedJsonFilterBase<$PrismaModel>>, 'path'>>
export type NestedEnumMcpTransportFilter<$PrismaModel = never> = {
equals?: $Enums.McpTransport | Prisma.EnumMcpTransportFieldRefInput<$PrismaModel>
in?: $Enums.McpTransport[] | Prisma.ListEnumMcpTransportFieldRefInput<$PrismaModel>
notIn?: $Enums.McpTransport[] | Prisma.ListEnumMcpTransportFieldRefInput<$PrismaModel>
not?: Prisma.NestedEnumMcpTransportFilter<$PrismaModel> | $Enums.McpTransport
}
export type NestedJsonFilterBase<$PrismaModel = never> = {
equals?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | Prisma.JsonNullValueFilter
path?: string[]
mode?: Prisma.QueryMode | Prisma.EnumQueryModeFieldRefInput<$PrismaModel>
string_contains?: string | Prisma.StringFieldRefInput<$PrismaModel>
string_starts_with?: string | Prisma.StringFieldRefInput<$PrismaModel>
string_ends_with?: string | Prisma.StringFieldRefInput<$PrismaModel>
array_starts_with?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | null
array_ends_with?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | null
array_contains?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | null
lt?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel>
lte?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel>
gt?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel>
gte?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel>
not?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | Prisma.JsonNullValueFilter
export type NestedEnumMcpTransportWithAggregatesFilter<$PrismaModel = never> = {
equals?: $Enums.McpTransport | Prisma.EnumMcpTransportFieldRefInput<$PrismaModel>
in?: $Enums.McpTransport[] | Prisma.ListEnumMcpTransportFieldRefInput<$PrismaModel>
notIn?: $Enums.McpTransport[] | Prisma.ListEnumMcpTransportFieldRefInput<$PrismaModel>
not?: Prisma.NestedEnumMcpTransportWithAggregatesFilter<$PrismaModel> | $Enums.McpTransport
_count?: Prisma.NestedIntFilter<$PrismaModel>
_min?: Prisma.NestedEnumMcpTransportFilter<$PrismaModel>
_max?: Prisma.NestedEnumMcpTransportFilter<$PrismaModel>
}
export type NestedEnumAgentSessionTypeFilter<$PrismaModel = never> = {
+29
View File
@@ -132,6 +132,7 @@ export const WorkflowTaskType = {
transcode_pdf_pages: 'transcode_pdf_pages',
transcode_screenshot: 'transcode_screenshot',
transcode_image_annotation: 'transcode_image_annotation',
transcode_watermark: 'transcode_watermark',
ai_metadata_autofill: 'ai_metadata_autofill',
chat: 'chat',
ai_embedding: 'ai_embedding',
@@ -152,6 +153,26 @@ export const WorkflowTaskStatus = {
export type WorkflowTaskStatus = (typeof WorkflowTaskStatus)[keyof typeof WorkflowTaskStatus]
export const WatermarkStatus = {
disabled: 'disabled',
processing: 'processing',
ready: 'ready',
failed: 'failed'
} as const
export type WatermarkStatus = (typeof WatermarkStatus)[keyof typeof WatermarkStatus]
export const WatermarkFileStatus = {
pending: 'pending',
processing: 'processing',
completed: 'completed',
failed: 'failed'
} as const
export type WatermarkFileStatus = (typeof WatermarkFileStatus)[keyof typeof WatermarkFileStatus]
export const AgentType = {
chat: 'chat',
autofill: 'autofill',
@@ -168,3 +189,11 @@ export const AgentSessionType = {
} as const
export type AgentSessionType = (typeof AgentSessionType)[keyof typeof AgentSessionType]
export const McpTransport = {
streamable_http: 'streamable_http',
sse: 'sse'
} as const
export type McpTransport = (typeof McpTransport)[keyof typeof McpTransport]
File diff suppressed because one or more lines are too long
+588 -2
View File
@@ -396,6 +396,9 @@ export const ModelName = {
Project: 'Project',
ProjectMember: 'ProjectMember',
ShareLink: 'ShareLink',
WatermarkConfig: 'WatermarkConfig',
WatermarkTemplate: 'WatermarkTemplate',
WatermarkFile: 'WatermarkFile',
Asset: 'Asset',
StorageKey: 'StorageKey',
AssetMetadataValue: 'AssetMetadataValue',
@@ -410,6 +413,9 @@ export const ModelName = {
WorkflowTask: 'WorkflowTask',
Agent: 'Agent',
AgentSkill: 'AgentSkill',
McpServer: 'McpServer',
AgentMcpServer: 'AgentMcpServer',
McpServerCredential: 'McpServerCredential',
AgentSession: 'AgentSession',
AgentSessionEntry: 'AgentSessionEntry',
UserMetadata: 'UserMetadata',
@@ -434,7 +440,7 @@ export type TypeMap<ExtArgs extends runtime.Types.Extensions.InternalArgs = runt
omit: GlobalOmitOptions
}
meta: {
modelProps: "user" | "session" | "account" | "verification" | "authToken" | "team" | "sandbox" | "skill" | "teamMember" | "project" | "projectMember" | "shareLink" | "asset" | "storageKey" | "assetMetadataValue" | "assetComment" | "assetCommentAttachment" | "assetEmbedding" | "invite" | "metadataField" | "notification" | "systemSettings" | "task" | "workflowTask" | "agent" | "agentSkill" | "agentSession" | "agentSessionEntry" | "userMetadata" | "model" | "provider" | "collection" | "apiToken" | "aiUsage" | "auditLog"
modelProps: "user" | "session" | "account" | "verification" | "authToken" | "team" | "sandbox" | "skill" | "teamMember" | "project" | "projectMember" | "shareLink" | "watermarkConfig" | "watermarkTemplate" | "watermarkFile" | "asset" | "storageKey" | "assetMetadataValue" | "assetComment" | "assetCommentAttachment" | "assetEmbedding" | "invite" | "metadataField" | "notification" | "systemSettings" | "task" | "workflowTask" | "agent" | "agentSkill" | "mcpServer" | "agentMcpServer" | "mcpServerCredential" | "agentSession" | "agentSessionEntry" | "userMetadata" | "model" | "provider" | "collection" | "apiToken" | "aiUsage" | "auditLog"
txIsolationLevel: TransactionIsolationLevel
}
model: {
@@ -1326,6 +1332,228 @@ export type TypeMap<ExtArgs extends runtime.Types.Extensions.InternalArgs = runt
}
}
}
WatermarkConfig: {
payload: Prisma.$WatermarkConfigPayload<ExtArgs>
fields: Prisma.WatermarkConfigFieldRefs
operations: {
findUnique: {
args: Prisma.WatermarkConfigFindUniqueArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$WatermarkConfigPayload> | null
}
findUniqueOrThrow: {
args: Prisma.WatermarkConfigFindUniqueOrThrowArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$WatermarkConfigPayload>
}
findFirst: {
args: Prisma.WatermarkConfigFindFirstArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$WatermarkConfigPayload> | null
}
findFirstOrThrow: {
args: Prisma.WatermarkConfigFindFirstOrThrowArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$WatermarkConfigPayload>
}
findMany: {
args: Prisma.WatermarkConfigFindManyArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$WatermarkConfigPayload>[]
}
create: {
args: Prisma.WatermarkConfigCreateArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$WatermarkConfigPayload>
}
createMany: {
args: Prisma.WatermarkConfigCreateManyArgs<ExtArgs>
result: BatchPayload
}
createManyAndReturn: {
args: Prisma.WatermarkConfigCreateManyAndReturnArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$WatermarkConfigPayload>[]
}
delete: {
args: Prisma.WatermarkConfigDeleteArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$WatermarkConfigPayload>
}
update: {
args: Prisma.WatermarkConfigUpdateArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$WatermarkConfigPayload>
}
deleteMany: {
args: Prisma.WatermarkConfigDeleteManyArgs<ExtArgs>
result: BatchPayload
}
updateMany: {
args: Prisma.WatermarkConfigUpdateManyArgs<ExtArgs>
result: BatchPayload
}
updateManyAndReturn: {
args: Prisma.WatermarkConfigUpdateManyAndReturnArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$WatermarkConfigPayload>[]
}
upsert: {
args: Prisma.WatermarkConfigUpsertArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$WatermarkConfigPayload>
}
aggregate: {
args: Prisma.WatermarkConfigAggregateArgs<ExtArgs>
result: runtime.Types.Utils.Optional<Prisma.AggregateWatermarkConfig>
}
groupBy: {
args: Prisma.WatermarkConfigGroupByArgs<ExtArgs>
result: runtime.Types.Utils.Optional<Prisma.WatermarkConfigGroupByOutputType>[]
}
count: {
args: Prisma.WatermarkConfigCountArgs<ExtArgs>
result: runtime.Types.Utils.Optional<Prisma.WatermarkConfigCountAggregateOutputType> | number
}
}
}
WatermarkTemplate: {
payload: Prisma.$WatermarkTemplatePayload<ExtArgs>
fields: Prisma.WatermarkTemplateFieldRefs
operations: {
findUnique: {
args: Prisma.WatermarkTemplateFindUniqueArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$WatermarkTemplatePayload> | null
}
findUniqueOrThrow: {
args: Prisma.WatermarkTemplateFindUniqueOrThrowArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$WatermarkTemplatePayload>
}
findFirst: {
args: Prisma.WatermarkTemplateFindFirstArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$WatermarkTemplatePayload> | null
}
findFirstOrThrow: {
args: Prisma.WatermarkTemplateFindFirstOrThrowArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$WatermarkTemplatePayload>
}
findMany: {
args: Prisma.WatermarkTemplateFindManyArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$WatermarkTemplatePayload>[]
}
create: {
args: Prisma.WatermarkTemplateCreateArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$WatermarkTemplatePayload>
}
createMany: {
args: Prisma.WatermarkTemplateCreateManyArgs<ExtArgs>
result: BatchPayload
}
createManyAndReturn: {
args: Prisma.WatermarkTemplateCreateManyAndReturnArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$WatermarkTemplatePayload>[]
}
delete: {
args: Prisma.WatermarkTemplateDeleteArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$WatermarkTemplatePayload>
}
update: {
args: Prisma.WatermarkTemplateUpdateArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$WatermarkTemplatePayload>
}
deleteMany: {
args: Prisma.WatermarkTemplateDeleteManyArgs<ExtArgs>
result: BatchPayload
}
updateMany: {
args: Prisma.WatermarkTemplateUpdateManyArgs<ExtArgs>
result: BatchPayload
}
updateManyAndReturn: {
args: Prisma.WatermarkTemplateUpdateManyAndReturnArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$WatermarkTemplatePayload>[]
}
upsert: {
args: Prisma.WatermarkTemplateUpsertArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$WatermarkTemplatePayload>
}
aggregate: {
args: Prisma.WatermarkTemplateAggregateArgs<ExtArgs>
result: runtime.Types.Utils.Optional<Prisma.AggregateWatermarkTemplate>
}
groupBy: {
args: Prisma.WatermarkTemplateGroupByArgs<ExtArgs>
result: runtime.Types.Utils.Optional<Prisma.WatermarkTemplateGroupByOutputType>[]
}
count: {
args: Prisma.WatermarkTemplateCountArgs<ExtArgs>
result: runtime.Types.Utils.Optional<Prisma.WatermarkTemplateCountAggregateOutputType> | number
}
}
}
WatermarkFile: {
payload: Prisma.$WatermarkFilePayload<ExtArgs>
fields: Prisma.WatermarkFileFieldRefs
operations: {
findUnique: {
args: Prisma.WatermarkFileFindUniqueArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$WatermarkFilePayload> | null
}
findUniqueOrThrow: {
args: Prisma.WatermarkFileFindUniqueOrThrowArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$WatermarkFilePayload>
}
findFirst: {
args: Prisma.WatermarkFileFindFirstArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$WatermarkFilePayload> | null
}
findFirstOrThrow: {
args: Prisma.WatermarkFileFindFirstOrThrowArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$WatermarkFilePayload>
}
findMany: {
args: Prisma.WatermarkFileFindManyArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$WatermarkFilePayload>[]
}
create: {
args: Prisma.WatermarkFileCreateArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$WatermarkFilePayload>
}
createMany: {
args: Prisma.WatermarkFileCreateManyArgs<ExtArgs>
result: BatchPayload
}
createManyAndReturn: {
args: Prisma.WatermarkFileCreateManyAndReturnArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$WatermarkFilePayload>[]
}
delete: {
args: Prisma.WatermarkFileDeleteArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$WatermarkFilePayload>
}
update: {
args: Prisma.WatermarkFileUpdateArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$WatermarkFilePayload>
}
deleteMany: {
args: Prisma.WatermarkFileDeleteManyArgs<ExtArgs>
result: BatchPayload
}
updateMany: {
args: Prisma.WatermarkFileUpdateManyArgs<ExtArgs>
result: BatchPayload
}
updateManyAndReturn: {
args: Prisma.WatermarkFileUpdateManyAndReturnArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$WatermarkFilePayload>[]
}
upsert: {
args: Prisma.WatermarkFileUpsertArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$WatermarkFilePayload>
}
aggregate: {
args: Prisma.WatermarkFileAggregateArgs<ExtArgs>
result: runtime.Types.Utils.Optional<Prisma.AggregateWatermarkFile>
}
groupBy: {
args: Prisma.WatermarkFileGroupByArgs<ExtArgs>
result: runtime.Types.Utils.Optional<Prisma.WatermarkFileGroupByOutputType>[]
}
count: {
args: Prisma.WatermarkFileCountArgs<ExtArgs>
result: runtime.Types.Utils.Optional<Prisma.WatermarkFileCountAggregateOutputType> | number
}
}
}
Asset: {
payload: Prisma.$AssetPayload<ExtArgs>
fields: Prisma.AssetFieldRefs
@@ -2362,6 +2590,228 @@ export type TypeMap<ExtArgs extends runtime.Types.Extensions.InternalArgs = runt
}
}
}
McpServer: {
payload: Prisma.$McpServerPayload<ExtArgs>
fields: Prisma.McpServerFieldRefs
operations: {
findUnique: {
args: Prisma.McpServerFindUniqueArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$McpServerPayload> | null
}
findUniqueOrThrow: {
args: Prisma.McpServerFindUniqueOrThrowArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$McpServerPayload>
}
findFirst: {
args: Prisma.McpServerFindFirstArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$McpServerPayload> | null
}
findFirstOrThrow: {
args: Prisma.McpServerFindFirstOrThrowArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$McpServerPayload>
}
findMany: {
args: Prisma.McpServerFindManyArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$McpServerPayload>[]
}
create: {
args: Prisma.McpServerCreateArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$McpServerPayload>
}
createMany: {
args: Prisma.McpServerCreateManyArgs<ExtArgs>
result: BatchPayload
}
createManyAndReturn: {
args: Prisma.McpServerCreateManyAndReturnArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$McpServerPayload>[]
}
delete: {
args: Prisma.McpServerDeleteArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$McpServerPayload>
}
update: {
args: Prisma.McpServerUpdateArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$McpServerPayload>
}
deleteMany: {
args: Prisma.McpServerDeleteManyArgs<ExtArgs>
result: BatchPayload
}
updateMany: {
args: Prisma.McpServerUpdateManyArgs<ExtArgs>
result: BatchPayload
}
updateManyAndReturn: {
args: Prisma.McpServerUpdateManyAndReturnArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$McpServerPayload>[]
}
upsert: {
args: Prisma.McpServerUpsertArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$McpServerPayload>
}
aggregate: {
args: Prisma.McpServerAggregateArgs<ExtArgs>
result: runtime.Types.Utils.Optional<Prisma.AggregateMcpServer>
}
groupBy: {
args: Prisma.McpServerGroupByArgs<ExtArgs>
result: runtime.Types.Utils.Optional<Prisma.McpServerGroupByOutputType>[]
}
count: {
args: Prisma.McpServerCountArgs<ExtArgs>
result: runtime.Types.Utils.Optional<Prisma.McpServerCountAggregateOutputType> | number
}
}
}
AgentMcpServer: {
payload: Prisma.$AgentMcpServerPayload<ExtArgs>
fields: Prisma.AgentMcpServerFieldRefs
operations: {
findUnique: {
args: Prisma.AgentMcpServerFindUniqueArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentMcpServerPayload> | null
}
findUniqueOrThrow: {
args: Prisma.AgentMcpServerFindUniqueOrThrowArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentMcpServerPayload>
}
findFirst: {
args: Prisma.AgentMcpServerFindFirstArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentMcpServerPayload> | null
}
findFirstOrThrow: {
args: Prisma.AgentMcpServerFindFirstOrThrowArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentMcpServerPayload>
}
findMany: {
args: Prisma.AgentMcpServerFindManyArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentMcpServerPayload>[]
}
create: {
args: Prisma.AgentMcpServerCreateArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentMcpServerPayload>
}
createMany: {
args: Prisma.AgentMcpServerCreateManyArgs<ExtArgs>
result: BatchPayload
}
createManyAndReturn: {
args: Prisma.AgentMcpServerCreateManyAndReturnArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentMcpServerPayload>[]
}
delete: {
args: Prisma.AgentMcpServerDeleteArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentMcpServerPayload>
}
update: {
args: Prisma.AgentMcpServerUpdateArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentMcpServerPayload>
}
deleteMany: {
args: Prisma.AgentMcpServerDeleteManyArgs<ExtArgs>
result: BatchPayload
}
updateMany: {
args: Prisma.AgentMcpServerUpdateManyArgs<ExtArgs>
result: BatchPayload
}
updateManyAndReturn: {
args: Prisma.AgentMcpServerUpdateManyAndReturnArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentMcpServerPayload>[]
}
upsert: {
args: Prisma.AgentMcpServerUpsertArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentMcpServerPayload>
}
aggregate: {
args: Prisma.AgentMcpServerAggregateArgs<ExtArgs>
result: runtime.Types.Utils.Optional<Prisma.AggregateAgentMcpServer>
}
groupBy: {
args: Prisma.AgentMcpServerGroupByArgs<ExtArgs>
result: runtime.Types.Utils.Optional<Prisma.AgentMcpServerGroupByOutputType>[]
}
count: {
args: Prisma.AgentMcpServerCountArgs<ExtArgs>
result: runtime.Types.Utils.Optional<Prisma.AgentMcpServerCountAggregateOutputType> | number
}
}
}
McpServerCredential: {
payload: Prisma.$McpServerCredentialPayload<ExtArgs>
fields: Prisma.McpServerCredentialFieldRefs
operations: {
findUnique: {
args: Prisma.McpServerCredentialFindUniqueArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$McpServerCredentialPayload> | null
}
findUniqueOrThrow: {
args: Prisma.McpServerCredentialFindUniqueOrThrowArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$McpServerCredentialPayload>
}
findFirst: {
args: Prisma.McpServerCredentialFindFirstArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$McpServerCredentialPayload> | null
}
findFirstOrThrow: {
args: Prisma.McpServerCredentialFindFirstOrThrowArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$McpServerCredentialPayload>
}
findMany: {
args: Prisma.McpServerCredentialFindManyArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$McpServerCredentialPayload>[]
}
create: {
args: Prisma.McpServerCredentialCreateArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$McpServerCredentialPayload>
}
createMany: {
args: Prisma.McpServerCredentialCreateManyArgs<ExtArgs>
result: BatchPayload
}
createManyAndReturn: {
args: Prisma.McpServerCredentialCreateManyAndReturnArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$McpServerCredentialPayload>[]
}
delete: {
args: Prisma.McpServerCredentialDeleteArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$McpServerCredentialPayload>
}
update: {
args: Prisma.McpServerCredentialUpdateArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$McpServerCredentialPayload>
}
deleteMany: {
args: Prisma.McpServerCredentialDeleteManyArgs<ExtArgs>
result: BatchPayload
}
updateMany: {
args: Prisma.McpServerCredentialUpdateManyArgs<ExtArgs>
result: BatchPayload
}
updateManyAndReturn: {
args: Prisma.McpServerCredentialUpdateManyAndReturnArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$McpServerCredentialPayload>[]
}
upsert: {
args: Prisma.McpServerCredentialUpsertArgs<ExtArgs>
result: runtime.Types.Utils.PayloadToResult<Prisma.$McpServerCredentialPayload>
}
aggregate: {
args: Prisma.McpServerCredentialAggregateArgs<ExtArgs>
result: runtime.Types.Utils.Optional<Prisma.AggregateMcpServerCredential>
}
groupBy: {
args: Prisma.McpServerCredentialGroupByArgs<ExtArgs>
result: runtime.Types.Utils.Optional<Prisma.McpServerCredentialGroupByOutputType>[]
}
count: {
args: Prisma.McpServerCredentialCountArgs<ExtArgs>
result: runtime.Types.Utils.Optional<Prisma.McpServerCredentialCountAggregateOutputType> | number
}
}
}
AgentSession: {
payload: Prisma.$AgentSessionPayload<ExtArgs>
fields: Prisma.AgentSessionFieldRefs
@@ -3225,6 +3675,7 @@ export const ShareLinkScalarFieldEnum = {
expireAt: 'expireAt',
password: 'password',
isDisabled: 'isDisabled',
allowDownload: 'allowDownload',
defaultSortOrder: 'defaultSortOrder',
viewMode: 'viewMode',
fieldVisibility: 'fieldVisibility',
@@ -3232,12 +3683,50 @@ export const ShareLinkScalarFieldEnum = {
updatedAt: 'updatedAt',
projectId: 'projectId',
rootFolderId: 'rootFolderId',
creatorId: 'creatorId'
creatorId: 'creatorId',
watermarkConfigId: 'watermarkConfigId',
watermarkStatus: 'watermarkStatus'
} as const
export type ShareLinkScalarFieldEnum = (typeof ShareLinkScalarFieldEnum)[keyof typeof ShareLinkScalarFieldEnum]
export const WatermarkConfigScalarFieldEnum = {
id: 'id',
config: 'config',
hash: 'hash',
createdAt: 'createdAt',
updatedAt: 'updatedAt'
} as const
export type WatermarkConfigScalarFieldEnum = (typeof WatermarkConfigScalarFieldEnum)[keyof typeof WatermarkConfigScalarFieldEnum]
export const WatermarkTemplateScalarFieldEnum = {
id: 'id',
name: 'name',
config: 'config',
teamId: 'teamId',
createdAt: 'createdAt',
updatedAt: 'updatedAt'
} as const
export type WatermarkTemplateScalarFieldEnum = (typeof WatermarkTemplateScalarFieldEnum)[keyof typeof WatermarkTemplateScalarFieldEnum]
export const WatermarkFileScalarFieldEnum = {
id: 'id',
assetId: 'assetId',
watermarkConfigId: 'watermarkConfigId',
media: 'media',
status: 'status',
createdAt: 'createdAt',
updatedAt: 'updatedAt'
} as const
export type WatermarkFileScalarFieldEnum = (typeof WatermarkFileScalarFieldEnum)[keyof typeof WatermarkFileScalarFieldEnum]
export const AssetScalarFieldEnum = {
id: 'id',
name: 'name',
@@ -3453,6 +3942,55 @@ export const AgentSkillScalarFieldEnum = {
export type AgentSkillScalarFieldEnum = (typeof AgentSkillScalarFieldEnum)[keyof typeof AgentSkillScalarFieldEnum]
export const McpServerScalarFieldEnum = {
id: 'id',
name: 'name',
description: 'description',
instructions: 'instructions',
url: 'url',
transport: 'transport',
authConfig: 'authConfig',
config: 'config',
permission: 'permission',
tools: 'tools',
status: 'status',
lastError: 'lastError',
lastConnectedAt: 'lastConnectedAt',
createdAt: 'createdAt',
updatedAt: 'updatedAt',
teamId: 'teamId'
} as const
export type McpServerScalarFieldEnum = (typeof McpServerScalarFieldEnum)[keyof typeof McpServerScalarFieldEnum]
export const AgentMcpServerScalarFieldEnum = {
id: 'id',
agentId: 'agentId',
mcpServerId: 'mcpServerId',
createdAt: 'createdAt',
updatedAt: 'updatedAt'
} as const
export type AgentMcpServerScalarFieldEnum = (typeof AgentMcpServerScalarFieldEnum)[keyof typeof AgentMcpServerScalarFieldEnum]
export const McpServerCredentialScalarFieldEnum = {
id: 'id',
serverId: 'serverId',
serverUrl: 'serverUrl',
tokens: 'tokens',
clientInfo: 'clientInfo',
codeVerifier: 'codeVerifier',
oauthState: 'oauthState',
pendingAuth: 'pendingAuth',
createdAt: 'createdAt',
updatedAt: 'updatedAt'
} as const
export type McpServerCredentialScalarFieldEnum = (typeof McpServerCredentialScalarFieldEnum)[keyof typeof McpServerCredentialScalarFieldEnum]
export const AgentSessionScalarFieldEnum = {
id: 'id',
agentId: 'agentId',
@@ -3736,6 +4274,34 @@ export type ListEnumProjectMemberRoleFieldRefInput<$PrismaModel> = FieldRefInput
/**
* Reference to a field of type 'WatermarkStatus'
*/
export type EnumWatermarkStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'WatermarkStatus'>
/**
* Reference to a field of type 'WatermarkStatus[]'
*/
export type ListEnumWatermarkStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'WatermarkStatus[]'>
/**
* Reference to a field of type 'WatermarkFileStatus'
*/
export type EnumWatermarkFileStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'WatermarkFileStatus'>
/**
* Reference to a field of type 'WatermarkFileStatus[]'
*/
export type ListEnumWatermarkFileStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'WatermarkFileStatus[]'>
/**
* Reference to a field of type 'AssetType'
*/
@@ -3932,6 +4498,20 @@ export type ListEnumAgentTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$Pr
/**
* Reference to a field of type 'McpTransport'
*/
export type EnumMcpTransportFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'McpTransport'>
/**
* Reference to a field of type 'McpTransport[]'
*/
export type ListEnumMcpTransportFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'McpTransport[]'>
/**
* Reference to a field of type 'AgentSessionType'
*/
@@ -4067,6 +4647,9 @@ export type GlobalOmitConfig = {
project?: Prisma.ProjectOmit
projectMember?: Prisma.ProjectMemberOmit
shareLink?: Prisma.ShareLinkOmit
watermarkConfig?: Prisma.WatermarkConfigOmit
watermarkTemplate?: Prisma.WatermarkTemplateOmit
watermarkFile?: Prisma.WatermarkFileOmit
asset?: Prisma.AssetOmit
storageKey?: Prisma.StorageKeyOmit
assetMetadataValue?: Prisma.AssetMetadataValueOmit
@@ -4081,6 +4664,9 @@ export type GlobalOmitConfig = {
workflowTask?: Prisma.WorkflowTaskOmit
agent?: Prisma.AgentOmit
agentSkill?: Prisma.AgentSkillOmit
mcpServer?: Prisma.McpServerOmit
agentMcpServer?: Prisma.AgentMcpServerOmit
mcpServerCredential?: Prisma.McpServerCredentialOmit
agentSession?: Prisma.AgentSessionOmit
agentSessionEntry?: Prisma.AgentSessionEntryOmit
userMetadata?: Prisma.UserMetadataOmit
@@ -63,6 +63,9 @@ export const ModelName = {
Project: 'Project',
ProjectMember: 'ProjectMember',
ShareLink: 'ShareLink',
WatermarkConfig: 'WatermarkConfig',
WatermarkTemplate: 'WatermarkTemplate',
WatermarkFile: 'WatermarkFile',
Asset: 'Asset',
StorageKey: 'StorageKey',
AssetMetadataValue: 'AssetMetadataValue',
@@ -77,6 +80,9 @@ export const ModelName = {
WorkflowTask: 'WorkflowTask',
Agent: 'Agent',
AgentSkill: 'AgentSkill',
McpServer: 'McpServer',
AgentMcpServer: 'AgentMcpServer',
McpServerCredential: 'McpServerCredential',
AgentSession: 'AgentSession',
AgentSessionEntry: 'AgentSessionEntry',
UserMetadata: 'UserMetadata',
@@ -262,6 +268,7 @@ export const ShareLinkScalarFieldEnum = {
expireAt: 'expireAt',
password: 'password',
isDisabled: 'isDisabled',
allowDownload: 'allowDownload',
defaultSortOrder: 'defaultSortOrder',
viewMode: 'viewMode',
fieldVisibility: 'fieldVisibility',
@@ -269,12 +276,50 @@ export const ShareLinkScalarFieldEnum = {
updatedAt: 'updatedAt',
projectId: 'projectId',
rootFolderId: 'rootFolderId',
creatorId: 'creatorId'
creatorId: 'creatorId',
watermarkConfigId: 'watermarkConfigId',
watermarkStatus: 'watermarkStatus'
} as const
export type ShareLinkScalarFieldEnum = (typeof ShareLinkScalarFieldEnum)[keyof typeof ShareLinkScalarFieldEnum]
export const WatermarkConfigScalarFieldEnum = {
id: 'id',
config: 'config',
hash: 'hash',
createdAt: 'createdAt',
updatedAt: 'updatedAt'
} as const
export type WatermarkConfigScalarFieldEnum = (typeof WatermarkConfigScalarFieldEnum)[keyof typeof WatermarkConfigScalarFieldEnum]
export const WatermarkTemplateScalarFieldEnum = {
id: 'id',
name: 'name',
config: 'config',
teamId: 'teamId',
createdAt: 'createdAt',
updatedAt: 'updatedAt'
} as const
export type WatermarkTemplateScalarFieldEnum = (typeof WatermarkTemplateScalarFieldEnum)[keyof typeof WatermarkTemplateScalarFieldEnum]
export const WatermarkFileScalarFieldEnum = {
id: 'id',
assetId: 'assetId',
watermarkConfigId: 'watermarkConfigId',
media: 'media',
status: 'status',
createdAt: 'createdAt',
updatedAt: 'updatedAt'
} as const
export type WatermarkFileScalarFieldEnum = (typeof WatermarkFileScalarFieldEnum)[keyof typeof WatermarkFileScalarFieldEnum]
export const AssetScalarFieldEnum = {
id: 'id',
name: 'name',
@@ -490,6 +535,55 @@ export const AgentSkillScalarFieldEnum = {
export type AgentSkillScalarFieldEnum = (typeof AgentSkillScalarFieldEnum)[keyof typeof AgentSkillScalarFieldEnum]
export const McpServerScalarFieldEnum = {
id: 'id',
name: 'name',
description: 'description',
instructions: 'instructions',
url: 'url',
transport: 'transport',
authConfig: 'authConfig',
config: 'config',
permission: 'permission',
tools: 'tools',
status: 'status',
lastError: 'lastError',
lastConnectedAt: 'lastConnectedAt',
createdAt: 'createdAt',
updatedAt: 'updatedAt',
teamId: 'teamId'
} as const
export type McpServerScalarFieldEnum = (typeof McpServerScalarFieldEnum)[keyof typeof McpServerScalarFieldEnum]
export const AgentMcpServerScalarFieldEnum = {
id: 'id',
agentId: 'agentId',
mcpServerId: 'mcpServerId',
createdAt: 'createdAt',
updatedAt: 'updatedAt'
} as const
export type AgentMcpServerScalarFieldEnum = (typeof AgentMcpServerScalarFieldEnum)[keyof typeof AgentMcpServerScalarFieldEnum]
export const McpServerCredentialScalarFieldEnum = {
id: 'id',
serverId: 'serverId',
serverUrl: 'serverUrl',
tokens: 'tokens',
clientInfo: 'clientInfo',
codeVerifier: 'codeVerifier',
oauthState: 'oauthState',
pendingAuth: 'pendingAuth',
createdAt: 'createdAt',
updatedAt: 'updatedAt'
} as const
export type McpServerCredentialScalarFieldEnum = (typeof McpServerCredentialScalarFieldEnum)[keyof typeof McpServerCredentialScalarFieldEnum]
export const AgentSessionScalarFieldEnum = {
id: 'id',
agentId: 'agentId',

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