Skip to content

Evenfire is an intelligence layer platform for running LLM agents that take real actions, on your infrastructure

TypeScript

feat(desktop): move resources between folders and rename from row menus

Miguelon Peluchon18e240f911e2
diff --git a/desktop-app/src/__tests__/appService.gfs.test.ts b/desktop-app/src/__tests__/appService.gfs.test.ts
index 0c6b849f4..051ae7a19 100644
--- a/desktop-app/src/__tests__/appService.gfs.test.ts
+++ b/desktop-app/src/__tests__/appService.gfs.test.ts
@@ -23,6 +23,7 @@ function gfsService() {
createShare: ReturnType<typeof vi.fn>
listShares: ReturnType<typeof vi.fn>
revokeShare: ReturnType<typeof vi.fn>
+ moveResource: ReturnType<typeof vi.fn>
}
grantGfs: (
resourceId: string,
@@ -34,6 +35,12 @@ function gfsService() {
createGfsShare: (resourceId: string, subjectKeys: string[], drive?: string) => Promise<void>
listGfsShares: (resourceId: string, drive?: string) => Promise<unknown[]>
revokeGfsShare: (shareId: string) => Promise<void>
+ moveGfsResource: (
+ resourceId: string,
+ destinationId: string,
+ drive?: string,
+ ifMatch?: number
+ ) => Promise<{ resourceId: string; version: number }>
}
service.sessionToken = 'session-token'
service.gfsClient = {
@@ -41,11 +48,25 @@ function gfsService() {
createShare: vi.fn().mockResolvedValue(undefined),
listShares: vi.fn().mockResolvedValue([]),
revokeShare: vi.fn().mockResolvedValue(undefined),
+ moveResource: vi.fn().mockResolvedValue({ resourceId: RESOURCE_ID, version: 9 }),
}
return service
}
describe('AppService GFS delegation subject boundary', () => {
+ it('moves a resource into a destination folder through the user-plane GFS client', async () => {
+ const service = gfsService()
+ const destinationId = '33333333-3333-4333-8333-333333333333'
+
+ await service.moveGfsResource(RESOURCE_ID, destinationId, 'main', 8)
+
+ expect(service.gfsClient.moveResource).toHaveBeenCalledTimes(1)
+ expect(service.gfsClient.moveResource).toHaveBeenCalledWith(
+ { resourceId: RESOURCE_ID, drive: 'main', destinationId, ifMatch: 8 },
+ 'session-token'
+ )
+ })
+
it('forwards share list and revoke through the in-memory session token only', async () => {
const service = gfsService()
const shareId = '22222222-2222-4222-8222-222222222222'
diff --git a/desktop-app/src/appService.ts b/desktop-app/src/appService.ts
index d8abb6340..2535ad8c7 100644
--- a/desktop-app/src/appService.ts
+++ b/desktop-app/src/appService.ts
@@ -2488,6 +2488,23 @@ export class AppService {
)
}
+ /**
+ * Move a resource into a destination folder (PATCH newParentId). Move
+ * authority is parent-relative (write+delete on the old parent, write on the
+ * destination) and is enforced server-side; ifMatch pins the resource version.
+ */
+ async moveGfsResource(
+ resourceId: string,
+ destinationId: string,
+ drive?: string,
+ ifMatch?: number
+ ) {
+ return this.gfsClient.moveResource(
+ { resourceId, drive, destinationId, ifMatch },
+ this.requireSessionToken()
+ )
+ }
+
async deleteGfsResource(resourceId: string, drive?: string, ifMatch?: number) {
return this.gfsClient.deleteResource({ resourceId, drive, ifMatch }, this.requireSessionToken())
}
diff --git a/desktop-app/src/gfs/uriHandler.ts b/desktop-app/src/gfs/uriHandler.ts
index 6a87efaa7..20de03957 100644
--- a/desktop-app/src/gfs/uriHandler.ts
+++ b/desktop-app/src/gfs/uriHandler.ts
@@ -216,6 +216,19 @@ export interface GfsRenameInput {
ifMatch?: number
}
+/**
+ * Move a resource to a new parent folder. Authority is parent-relative
+ * (control-api applyResourcePatch: write+delete on the old parent, write on
+ * the destination) — the server adjudicates it; the client sends only the
+ * destination id plus the resource's If-Match version.
+ */
+export interface GfsMoveInput {
+ resourceId: string
+ drive?: string
+ destinationId: string
+ ifMatch?: number
+}
+
export interface GfsDeleteInput {
resourceId: string
drive?: string
@@ -334,6 +347,26 @@ async function renameGfsResource(
return unwrap(payload)
}
+async function moveGfsResource(
+ transport: GfsTransport,
+ input: GfsMoveInput,
+ session: string
+): Promise<{ resourceId: string; version: number }> {
+ const q = new URLSearchParams()
+ q.set('drive', input.drive ?? DEFAULT_DRIVE)
+ const body: Record<string, unknown> = { newParentId: input.destinationId }
+ if (input.ifMatch !== undefined) body.ifMatch = input.ifMatch
+ const path = `/api/v1/me/gfs/resources/${encodeURIComponent(input.resourceId)}?${q.toString()}`
+ const options = { body } as { token?: string; body?: unknown }
+ options[TRANSPORT_TOKEN_FIELD] = session
+ const payload = await transport.requestJson<GfsEnvelope<{ resourceId: string; version: number }>>(
+ 'PATCH',
+ joinUrl(transport.baseUrl, path),
+ options
+ )
+ return unwrap(payload)
+}
+
async function deleteGfsResource(
transport: GfsTransport,
input: GfsDeleteInput,
@@ -596,6 +629,13 @@ export class GfsClient {
return renameGfsResource(this.transport, input, session)
}
+ async moveResource(
+ input: GfsMoveInput,
+ session: string
+ ): Promise<{ resourceId: string; version: number }> {
+ return moveGfsResource(this.transport, input, session)
+ }
+
async deleteResource(
input: GfsDeleteInput,
session: string
diff --git a/desktop-app/src/ipc.ts b/desktop-app/src/ipc.ts
index 2eacf13d4..23f37e664 100644
--- a/desktop-app/src/ipc.ts
+++ b/desktop-app/src/ipc.ts
@@ -597,6 +597,22 @@ export function registerIpcHandlers(service: AppService): void {
)
}
)
+ ipcMain.handle(
+ 'gfs:moveResource',
+ async (
+ event,
+ payload: { resourceId: string; destinationId: string; drive?: string; ifMatch?: number }
+ ) => {
+ assertTrustedSender(event)
+ const drive = payload?.drive ? sanitizeString(payload.drive) : undefined
+ return service.moveGfsResource(
+ sanitizeString(payload?.resourceId),
+ sanitizeString(payload?.destinationId),
+ drive,
+ sanitizeOptionalInteger(payload?.ifMatch)
+ )
+ }
+ )
ipcMain.handle(
'gfs:deleteResource',
async (event, payload: { resourceId: string; drive?: string; ifMatch?: number }) => {
diff --git a/desktop-app/src/preload.ts b/desktop-app/src/preload.ts
index 3a38816ff..468b2c586 100644
--- a/desktop-app/src/preload.ts
+++ b/desktop-app/src/preload.ts
@@ -133,6 +133,8 @@ const clerum = Object.freeze({
getPathForFile: (file: File) => webUtils.getPathForFile(file),
renameResource: (resourceId: string, newName: string, drive?: string, ifMatch?: number) =>
ipcRenderer.invoke('gfs:renameResource', { resourceId, newName, drive, ifMatch }),
+ moveResource: (resourceId: string, destinationId: string, drive?: string, ifMatch?: number) =>
+ ipcRenderer.invoke('gfs:moveResource', { resourceId, destinationId, drive, ifMatch }),
deleteResource: (resourceId: string, drive?: string, ifMatch?: number) =>
ipcRenderer.invoke('gfs:deleteResource', { resourceId, drive, ifMatch }),
grant: (
diff --git a/desktop-app/src/renderer.d.ts b/desktop-app/src/renderer.d.ts
index 7831ce408..0b4e7a841 100644
--- a/desktop-app/src/renderer.d.ts
+++ b/desktop-app/src/renderer.d.ts
@@ -330,6 +330,12 @@ declare global {
drive?: string,
ifMatch?: number
) => Promise<{ resourceId: string; version: number }>
+ moveResource: (
+ resourceId: string,
+ destinationId: string,
+ drive?: string,
+ ifMatch?: number
+ ) => Promise<{ resourceId: string; version: number }>
deleteResource: (
resourceId: string,
drive?: string,
diff --git a/desktop-app/test/gfsUriHandler.test.ts b/desktop-app/test/gfsUriHandler.test.ts
index 566ddf801..619119e89 100644
--- a/desktop-app/test/gfsUriHandler.test.ts
+++ b/desktop-app/test/gfsUriHandler.test.ts
@@ -531,7 +531,7 @@ describe('GfsClient resource mutations', () => {
)
})
- it('replaces, renames, and deletes with If-Match through the user plane', async () => {
+ it('replaces, renames, deletes, and moves with If-Match through the user plane', async () => {
const requestJson = vi.fn(async () => ({
ok: true,
data: CHILD,
@@ -540,6 +540,10 @@ describe('GfsClient resource mutations', () => {
await client.replaceFile({ resourceId: RID, encodedData: 'aGVsbG8=', ifMatch: 1 }, 'tok')
await client.renameResource({ resourceId: RID, newName: 'renamed.md', ifMatch: 2 }, 'tok')
await client.deleteResource({ resourceId: RID, ifMatch: 3 }, 'tok')
+ await client.moveResource(
+ { resourceId: RID, destinationId: '22222222-2222-2222-2222-222222222222', ifMatch: 4 },
+ 'tok'
+ )
expect(requestJson).toHaveBeenNthCalledWith(
1,
'PUT',
@@ -562,6 +566,15 @@ describe('GfsClient resource mutations', () => {
`https://api.example/api/v1/me/gfs/resources/${RID}?drive=main`,
{ token: 'tok', body: { ifMatch: 3 } }
)
+ expect(requestJson).toHaveBeenNthCalledWith(
+ 4,
+ 'PATCH',
+ `https://api.example/api/v1/me/gfs/resources/${RID}?drive=main`,
+ {
+ token: 'tok',
+ body: { newParentId: '22222222-2222-2222-2222-222222222222', ifMatch: 4 },
+ }
+ )
})
})
diff --git a/desktop-app/ui/src/components/GfsResourceMenu/index.tsx b/desktop-app/ui/src/components/GfsResourceMenu/index.tsx
index b987a2c67..c6fb50056 100644
--- a/desktop-app/ui/src/components/GfsResourceMenu/index.tsx
+++ b/desktop-app/ui/src/components/GfsResourceMenu/index.tsx
@@ -16,6 +16,7 @@ export function GfsResourceMenu({
onPreview,
onDownload,
onRename,
+ onMove,
}: GfsResourceMenuProps) {
const [open, setOpen] = useState(false)
const menuRef = useRef<HTMLSpanElement | null>(null)
@@ -125,6 +126,11 @@ export function GfsResourceMenu({
Rename
</MenuItem>
) : null}
+ {onMove ? (
+ <MenuItem role="menuitem" onClick={() => runAction(onMove)}>
+ Move to…
+ </MenuItem>
+ ) : null}
{onDownload ? (
<MenuItem role="menuitem" onClick={() => runAction(onDownload)}>
Download
diff --git a/desktop-app/ui/src/components/GfsResourceMenu/types.ts b/desktop-app/ui/src/components/GfsResourceMenu/types.ts
index edc36f180..b4ca9834d 100644
--- a/desktop-app/ui/src/components/GfsResourceMenu/types.ts
+++ b/desktop-app/ui/src/components/GfsResourceMenu/types.ts
@@ -13,4 +13,7 @@ export type GfsResourceMenuProps = {
onPreview?: () => void
onDownload?: () => void
onRename?: () => void
+ /** Open the move-to-folder flow. Move authority is parent-relative and
+ * enforced server-side, so callers do NOT gate this on local affordances. */
+ onMove?: () => void
}
diff --git a/desktop-app/ui/src/constants/gfsBrowser.ts b/desktop-app/ui/src/constants/gfsBrowser.ts
index 4fb64f4db..2e4f57a40 100644
--- a/desktop-app/ui/src/constants/gfsBrowser.ts
+++ b/desktop-app/ui/src/constants/gfsBrowser.ts
@@ -1 +1,4 @@
export const GFS_BREADCRUMB_MAX_DEPTH = 64
+
+/** Drive the desktop Files page browses (single-drive user plane today). */
+export const GFS_DRIVE_MAIN = 'main'
diff --git a/desktop-app/ui/src/gfs/moveDialog.tsx b/desktop-app/ui/src/gfs/moveDialog.tsx
new file mode 100644
index 000000000..7a6cdd82b
--- /dev/null
+++ b/desktop-app/ui/src/gfs/moveDialog.tsx
@@ -0,0 +1,186 @@
+import { useMemo, useState } from 'react'
+import { useInfiniteQuery } from '@tanstack/react-query'
+import { Button, IconButton, StatusBanner } from '@components/Common'
+import { IconClose, IconContexts } from '@components/SidebarNav/icons'
+import { GFS_DRIVE_MAIN } from '@constants/gfsBrowser'
+import { desktopQueryKeys } from '@hooks/domain/queryKeys'
+import type { GfsBrowserChild, GfsCrumb } from '@hooks/domain/useGfsBrowserController'
+import type { GfsMoveDialogProps } from './moveDialog.types'
+
+/**
+ * Folder-picker dialog for moving a gfs resource (PATCH newParentId). Browsing
+ * reuses the Files page's TanStack keys (accessible roots + folder children),
+ * so already-loaded folders render instantly and stay coherent with the page.
+ *
+ * Cycle safety: "Move here" is disabled while the dialog path passes through
+ * the target itself (a folder cannot move into its own subtree — the server
+ * would reject it with path_invalid). Move AUTHORITY is parent-relative and
+ * enforced server-side; a 403/412 from the commit surfaces as an in-dialog
+ * banner so the user can pick a different folder without reopening.
+ */
+export function GfsMoveDialog({
+ target,
+ sessionScope,
+ initialCrumbs,
+ onMove,
+ onClose,
+ busy = false,
+}: GfsMoveDialogProps) {
+ const [crumbs, setCrumbs] = useState<GfsCrumb[]>(initialCrumbs)
+ const [error, setError] = useState<string | null>(null)
+ const current = crumbs.length ? crumbs[crumbs.length - 1] : null
+ const scope = sessionScope ?? 'anonymous'
+
+ const accessibleQuery = useInfiniteQuery({
+ queryKey: desktopQueryKeys.gfsAccessible(scope, GFS_DRIVE_MAIN),
+ queryFn: ({ pageParam }) =>
+ window.clerum?.gfs?.listAccessible(GFS_DRIVE_MAIN, pageParam) ??
+ Promise.resolve({ items: [], nextCursor: null }),
+ enabled: current === null,
+ initialPageParam: undefined as string | undefined,
+ getNextPageParam: lastPage => lastPage.nextCursor ?? undefined,
+ })
+ const childrenQuery = useInfiniteQuery({
+ queryKey: desktopQueryKeys.gfsChildren(scope, current?.resourceId ?? '', GFS_DRIVE_MAIN),
+ queryFn: ({ pageParam }) =>
+ window.clerum.gfs.listChildren(current!.resourceId, GFS_DRIVE_MAIN, pageParam),
+ enabled: current !== null,
+ initialPageParam: undefined as string | undefined,
+ getNextPageParam: lastPage => lastPage.nextCursor ?? undefined,
+ })
+
+ const folders = useMemo(() => {
+ const source: Array<GfsBrowserChild & { kind: 'file' | 'directory' }> =
+ current === null
+ ? (accessibleQuery.data?.pages ?? []).flatMap(page => page.items)
+ : (childrenQuery.data?.pages ?? []).flatMap(page => page.items)
+ return source.filter(item => item.kind === 'directory' && item.resourceId !== target.resourceId)
+ }, [accessibleQuery.data, childrenQuery.data, current, target.resourceId])
+
+ // The dialog path itself must never run through the moved folder.
+ const pathPassesThroughTarget = crumbs.some(crumb => crumb.resourceId === target.resourceId)
+ const loading = current === null ? accessibleQuery.isFetching : childrenQuery.isFetching
+ const listError =
+ current === null
+ ? (accessibleQuery.error?.message ?? null)
+ : (childrenQuery.error?.message ?? null)
+
+ const enterFolder = (folder: GfsBrowserChild) => {
+ setError(null)
+ setCrumbs(prev => [
+ ...prev,
+ {
+ resourceId: folder.resourceId,
+ gfsUri: folder.gfsUri,
+ name: folder.name,
+ kind: 'directory',
+ version: folder.version,
+ bytes: folder.bytes,
+ },
+ ])
+ }
+
+ const commit = async () => {
+ if (!current) return
+ setError(null)
+ try {
+ await onMove(current.resourceId, current.name)
+ } catch (moveError) {
+ setError(moveError instanceof Error ? moveError.message : String(moveError))
+ }
+ }
+
+ return (
+ <div
+ className="da-gfs-manage-modal"
+ role="presentation"
+ onMouseDown={event => {
+ if (event.target === event.currentTarget) onClose()
+ }}
+ >
+ <section
+ className="da-gfs-manage-dialog da-gfs-move-dialog"
+ role="dialog"
+ aria-modal="true"
+ aria-label={`Move ${target.kind === 'directory' ? 'folder' : 'file'} ${target.name}`}
+ >
+ <header className="da-gfs-manage-dialog__header">
+ <span className="da-gfs-manage-dialog__icon" aria-hidden="true">
+ <IconContexts />
+ </span>
+ <span className="da-gfs-manage-dialog__heading">
+ <h3>Move {target.name}</h3>
+ <span className="muted">Choose a destination folder.</span>
+ </span>
+ <span className="da-gfs-manage-dialog__top-actions">
+ <IconButton label="Close move dialog" onClick={onClose} size="sm" variant="ghost">
+ <IconClose />
+ </IconButton>
+ </span>
+ </header>
+ <div className="da-gfs-manage-dialog__body">
+ <nav className="da-gfs-drive__breadcrumbs" aria-label="Move destination">
+ <Button
+ className="da-gfs-drive__breadcrumb"
+ color="neutral"
+ disabled={current === null}
+ onClick={() => setCrumbs([])}
+ variant="text"
+ >
+ Shared with me
+ </Button>
+ {crumbs.map((crumb, index) => (
+ <span className="da-gfs-drive__crumb-group" key={crumb.resourceId}>
+ <Button
+ className="da-gfs-drive__breadcrumb"
+ color="neutral"
+ disabled={index === crumbs.length - 1}
+ onClick={() => setCrumbs(prev => prev.slice(0, index + 1))}
+ variant="text"
+ >
+ {crumb.name}
+ </Button>
+ </span>
+ ))}
+ </nav>
+ {error ? <StatusBanner tone="error" text={error} /> : null}
+ {listError ? <StatusBanner tone="error" text={listError} /> : null}
+ <div className="da-gfs-move-dialog__list" role="list">
+ {loading && folders.length === 0 ? (
+ <p className="muted">Loading folders…</p>
+ ) : folders.length === 0 ? (
+ <p className="muted">No folders here.</p>
+ ) : (
+ folders.map(folder => (
+ <div className="da-gfs-move-dialog__row" role="listitem" key={folder.resourceId}>
+ <span className="da-gfs-move-dialog__row-icon" aria-hidden="true">
+ <IconContexts />
+ </span>
+ <Button align="start" block onClick={() => enterFolder(folder)} variant="text">
+ {folder.name}
+ </Button>
+ </div>
+ ))
+ )}
+ </div>
+ <div className="da-gfs-move-dialog__actions">
+ <Button onClick={onClose} type="button" variant="ghost">
+ Cancel
+ </Button>
+ <Button
+ disabled={current === null || pathPassesThroughTarget}
+ loading={busy}
+ onClick={() => void commit()}
+ type="button"
+ >
+ Move here{current ? ` (${current.name})` : ''}
+ </Button>
+ </div>
+ {pathPassesThroughTarget ? (
+ <p className="muted">A folder can’t be moved into its own subtree.</p>
+ ) : null}
+ </div>
+ </section>
+ </div>
+ )
+}
diff --git a/desktop-app/ui/src/gfs/moveDialog.types.ts b/desktop-app/ui/src/gfs/moveDialog.types.ts
new file mode 100644
index 000000000..90c8e8979
--- /dev/null
+++ b/desktop-app/ui/src/gfs/moveDialog.types.ts
@@ -0,0 +1,15 @@
+import type { GfsCrumb } from '@hooks/domain/useGfsBrowserController'
+
+export type GfsMoveDialogProps = {
+ /** The resource being moved (kind powers the dialog title + cycle guard). */
+ target: { resourceId: string; name: string; kind: 'file' | 'directory' }
+ /** Cache scope from useGfsBrowserController — shares the page's gfs queries. */
+ sessionScope?: string
+ /** Dialog-local starting path (typically the page crumbs, minus the target). */
+ initialCrumbs: GfsCrumb[]
+ /** Commit the move; resolves on success (caller toasts) and throws the
+ * server verdict on denial so the dialog can surface it in place. */
+ onMove: (destinationId: string, destinationName: string) => Promise<void>
+ onClose: () => void
+ busy?: boolean
+}
diff --git a/desktop-app/ui/src/hooks/domain/useGfsBrowserController.ts b/desktop-app/ui/src/hooks/domain/useGfsBrowserController.ts
index cee86594e..7ea89878c 100644
--- a/desktop-app/ui/src/hooks/domain/useGfsBrowserController.ts
+++ b/desktop-app/ui/src/hooks/domain/useGfsBrowserController.ts
@@ -263,6 +263,16 @@ export function useGfsBrowserController(options: GfsBrowserControllerOptions = {
await refreshGfs()
},
})
+ // Move refreshes the old parent's children, the destination's children, and
+ // the accessible roots in one shot via refreshGfs. The moved resource's own
+ // crumbs stay valid (its id does not change); only its parent does.
+ const moveResourceMutation = useMutation({
+ mutationFn: (input: { resourceId: string; destinationId: string; ifMatch?: number }) =>
+ window.clerum.gfs.moveResource(input.resourceId, input.destinationId, DRIVE, input.ifMatch),
+ onSuccess: async () => {
+ await refreshGfs()
+ },
+ })
const items = useMemo<GfsBrowserChild[]>(
() => (childrenQuery.data?.pages ?? []).flatMap(page => page.items),
@@ -400,6 +410,9 @@ export function useGfsBrowserController(options: GfsBrowserControllerOptions = {
return {
crumbs,
current,
+ /** Cache-scope key (env + user + team) so the move dialog's queries share
+ * the controller's cache and are dropped together on scope change. */
+ sessionScope: sessionScope ?? 'anonymous',
accessibleResources,
items,
affordances: (affordancesQuery.data as GfsBrowserAffordances | undefined) ?? null,
@@ -451,6 +464,8 @@ export function useGfsBrowserController(options: GfsBrowserControllerOptions = {
replaceFileMutation.mutateAsync({ resourceId, encodedData, ifMatch }),
renameResource: (resourceId: string, name: string, ifMatch?: number) =>
renameResourceMutation.mutateAsync({ resourceId, name, ifMatch }),
+ moveResource: (resourceId: string, destinationId: string, ifMatch?: number) =>
+ moveResourceMutation.mutateAsync({ resourceId, destinationId, ifMatch }),
deleteResource: (resourceId: string, ifMatch?: number) =>
deleteResourceMutation.mutateAsync({ resourceId, ifMatch }),
mutating:
@@ -458,6 +473,7 @@ export function useGfsBrowserController(options: GfsBrowserControllerOptions = {
createFileMutation.isPending ||
replaceFileMutation.isPending ||
renameResourceMutation.isPending ||
+ moveResourceMutation.isPending ||
deleteResourceMutation.isPending,
}
}
diff --git a/desktop-app/ui/src/pages/FilesPage.tsx b/desktop-app/ui/src/pages/FilesPage.tsx
index 051fff802..45feeddb0 100644
--- a/desktop-app/ui/src/pages/FilesPage.tsx
+++ b/desktop-app/ui/src/pages/FilesPage.tsx
@@ -30,6 +30,7 @@ import {
type GfsDelegationSubjectOption,
} from '@/gfs/delegation'
import { GfsFilePicker } from '@/gfs/filePicker'
+import { GfsMoveDialog } from '@/gfs/moveDialog'
import { normalizeGfsResourceName } from '@/gfs/resourceName'
import type { TeamDirectoryResult } from '../../../src/types'
import type {
@@ -118,13 +119,24 @@ function mergeErrorMessages(...errors: unknown[]): string | null {
return messages.length > 0 ? messages.join(' · ') : null
}
+/** Any row/header action target — a listing row (GfsDriveResource) or the
+ * current breadcrumb (GfsCrumb); both carry the identity fields the delete /
+ * rename / move calls need (kind also powers dialog titles + the move cycle
+ * guard). */
+type GfsActionTarget = Pick<GfsDriveResource, 'resourceId' | 'name' | 'version'> & {
+ kind: 'file' | 'directory'
+}
+
export function FilesPage({ pushToast, pendingGfsUri, onPendingGfsUriHandled }: FilesPageProps) {
const [createFolderName, setCreateFolderName] = useState('')
const [createFolderOpen, setCreateFolderOpen] = useState(false)
const [renameName, setRenameName] = useState('')
const [renameOpen, setRenameOpen] = useState(false)
const [deleteOpen, setDeleteOpen] = useState(false)
- const [deleteTarget, setDeleteTarget] = useState<GfsDriveResource | null>(null)
+ const [deleteTarget, setDeleteTarget] = useState<GfsActionTarget | null>(null)
+ const [moveTarget, setMoveTarget] = useState<GfsActionTarget | null>(null)
+ const [renameTarget, setRenameTarget] = useState<GfsActionTarget | null>(null)
+ const [renameDraft, setRenameDraft] = useState('')
const [openLinkOpen, setOpenLinkOpen] = useState(false)
const [manageOpen, setManageOpen] = useState(false)
const [filePreview, setFilePreview] = useState<GfsPreviewResource | null>(null)
@@ -136,6 +148,7 @@ export function FilesPage({ pushToast, pendingGfsUri, onPendingGfsUriHandled }:
const {
current,
crumbs,
+ sessionScope,
accessibleResources,
items,
affordances,
@@ -244,15 +257,17 @@ export function FilesPage({ pushToast, pendingGfsUri, onPendingGfsUriHandled }:
}
useEffect(() => {
- if (!manageOpen && !openLinkOpen) return
+ if (!manageOpen && !openLinkOpen && !moveTarget && !renameTarget) return
const handleKeyDown = (event: KeyboardEvent) => {
if (event.key !== 'Escape') return
setManageOpen(false)
setOpenLinkOpen(false)
+ setMoveTarget(null)
+ setRenameTarget(null)
}
window.addEventListener('keydown', handleKeyDown)
return () => window.removeEventListener('keydown', handleKeyDown)
- }, [manageOpen, openLinkOpen])
+ }, [manageOpen, openLinkOpen, moveTarget, renameTarget])
// One atomic bulk grant for every selected subject — the server grants all or
// none (a `subjects_invalid` rejects the whole request), so there is no
@@ -457,7 +472,7 @@ export function FilesPage({ pushToast, pendingGfsUri, onPendingGfsUriHandled }:
}
}
- const handleDeleteResource = async (resource: GfsDriveResource) => {
+ const handleDeleteResource = async (resource: GfsActionTarget) => {
try {
await ctrl.deleteResource(resource.resourceId, resource.version)
pushToast?.(`Deleted ${resource.name}`, 'success')
@@ -483,6 +498,59 @@ export function FilesPage({ pushToast, pendingGfsUri, onPendingGfsUriHandled }:
return Boolean(resource.permissions?.includes('delete'))
}
+ /** Rename gate: same lazy resolution as rowCanDelete, but on the write bit
+ * (rename needs `write` on the resource itself). */
+ const rowCanRename = (resource: GfsDriveResource): boolean => {
+ if (currentIsFolder) {
+ return (
+ ctrl.rowAffordancesResourceId === resource.resourceId &&
+ Boolean(ctrl.rowAffordances?.held.includes('write'))
+ )
+ }
+ return Boolean(resource.permissions?.includes('write'))
+ }
+
+ /** Move commits bubble their failure back to the dialog (in-place banner);
+ * success toasts and closes it. ifMatch pins the resource version. */
+ const handleMoveTarget = async (destinationId: string, destinationName: string) => {
+ if (!moveTarget) return
+ const target = moveTarget
+ await ctrl.moveResource(target.resourceId, destinationId, target.version)
+ setMoveTarget(null)
+ pushToast?.(`Moved ${target.name} to ${destinationName}`, 'success')
+ }
+
+ const requestMoveCurrent = () => {
+ if (current) setMoveTarget(current)
+ }
+
+ /** Page-level rename works for any row or the current resource; the manage
+ * dialog keeps its own inline title-edit flow. Errors toast (stale version
+ * → retry), matching the manage-dialog rename behavior. */
+ const handleRenameTarget = async () => {
+ if (!renameTarget) return
+ const target = renameTarget
+ const requestedName = renameDraft.trim()
+ if (!requestedName) return
+ try {
+ const name = await normalizeGfsResourceName(requestedName)
+ if (name === target.name) {
+ setRenameTarget(null)
+ return
+ }
+ await ctrl.renameResource(target.resourceId, name, target.version)
+ setRenameTarget(null)
+ pushToast?.(`Renamed to ${name}`, 'success')
+ } catch (renameError) {
+ pushToast?.(renameError instanceof Error ? renameError.message : String(renameError), 'error')
+ }
+ }
+
+ const openRenameTarget = (target: GfsActionTarget) => {
+ setRenameTarget(target)
+ setRenameDraft(target.name)
+ }
+
const visibleResources = useMemo<GfsDriveResource[]>(() => {
const resources = currentIsFolder ? items : currentIsFile ? [] : accessibleResources
return [...resources].sort((left, right) => {
@@ -570,6 +638,9 @@ export function FilesPage({ pushToast, pendingGfsUri, onPendingGfsUriHandled }:
setManageOpen(true)
}}
onCopyLink={() => void handleCopyLink(current.gfsUri)}
+ onDelete={canDeleteCurrent ? () => setDeleteTarget(current) : undefined}
+ onRename={canWriteCurrent ? () => openRenameTarget(current) : undefined}
+ onMove={requestMoveCurrent}
/>
) : null}
</div>
@@ -629,6 +700,9 @@ export function FilesPage({ pushToast, pendingGfsUri, onPendingGfsUriHandled }:
setManageOpen(true)
}}
onCopyLink={() => void handleCopyLink(current.gfsUri)}
+ onDelete={canDeleteCurrent ? () => setDeleteTarget(current) : undefined}
+ onRename={canWriteCurrent ? () => openRenameTarget(current) : undefined}
+ onMove={requestMoveCurrent}
onPreview={
currentPreviewAvailable ? () => void openFilePreview(current) : undefined
}
@@ -737,6 +811,10 @@ export function FilesPage({ pushToast, pendingGfsUri, onPendingGfsUriHandled }:
onOpenChange={open =>
ctrl.setRowAffordancesResourceId(open ? resource.resourceId : null)
}
+ onRename={
+ rowCanRename(resource) ? () => openRenameTarget(resource) : undefined
+ }
+ onMove={() => setMoveTarget(resource)}
onPreview={
isGfsPreviewFile(resource.name)
? () => void openFilePreview(resource)
@@ -888,6 +966,7 @@ export function FilesPage({ pushToast, pendingGfsUri, onPendingGfsUriHandled }:
}
: undefined
}
+ onMove={requestMoveCurrent}
onDownload={
currentIsFile
? () => void handleDownload(current.gfsUri, current.name)
@@ -1118,6 +1197,67 @@ export function FilesPage({ pushToast, pendingGfsUri, onPendingGfsUriHandled }:
tone="danger"
/>
) : null}
+
+ {moveTarget ? (
+ <GfsMoveDialog
+ busy={ctrl.mutating}
+ initialCrumbs={
+ moveTarget.resourceId === current?.resourceId ? crumbs.slice(0, -1) : crumbs
+ }
+ onClose={() => setMoveTarget(null)}
+ onMove={handleMoveTarget}
+ sessionScope={sessionScope}
+ target={moveTarget}
+ />
+ ) : null}
+
+ {renameTarget ? (
+ <div
+ className="da-gfs-manage-modal"
+ role="presentation"
+ onMouseDown={event => {
+ if (event.target === event.currentTarget) setRenameTarget(null)
+ }}
+ >
+ <section
+ className="da-gfs-manage-dialog da-gfs-manage-dialog--confirm"
+ role="dialog"
+ aria-modal="true"
+ aria-label="Rename resource"
+ >
+ <div className="da-gfs-manage-dialog__body">
+ <form
+ className="da-gfs-inline-form"
+ onSubmit={event => {
+ event.preventDefault()
+ void handleRenameTarget()
+ }}
+ >
+ <label className="da-gfs-inline-form__field">
+ <span>New name for {renameTarget.name}</span>
+ <TextInput
+ autoFocus
+ aria-label="New name"
+ value={renameDraft}
+ onChange={event => setRenameDraft(event.currentTarget.value)}
+ />
+ </label>
+ <Button loading={ctrl.mutating} size="sm" type="submit">
+ Save
+ </Button>
+ <Button
+ onClick={() => setRenameTarget(null)}
+ size="sm"
+ type="button"
+ variant="ghost"
+ >
+ Cancel
+ </Button>
+ </form>
+ </div>
+ </section>
+ </div>
+ ) : null}
</section>
)
}
diff --git a/desktop-app/ui/src/pages/__tests__/FilesPage.test.tsx b/desktop-app/ui/src/pages/__tests__/FilesPage.test.tsx
index 1f987c5ea..b6874be7a 100644
--- a/desktop-app/ui/src/pages/__tests__/FilesPage.test.tsx
+++ b/desktop-app/ui/src/pages/__tests__/FilesPage.test.tsx
@@ -20,6 +20,7 @@ function baseController() {
return {
current: null,
crumbs: [],
+ sessionScope: 'env-1:user-1:team-1',
accessibleResources: [],
items: [],
affordances: null,
@@ -58,6 +59,7 @@ function baseController() {
createFile: vi.fn(),
replaceFile: vi.fn(),
renameResource: vi.fn(),
+ moveResource: vi.fn(),
deleteResource: vi.fn(),
mutating: false,
reset: vi.fn(),
@@ -1270,6 +1272,166 @@ describe('FilesPage', () => {
expect(screen.queryByRole('dialog')).toBeNull()
})
+ it('moves a folder child into another folder through the move dialog', async () => {
+ const pushToast = vi.fn()
+ const moveResource = vi.fn(async () => ({}))
+ const listChildren = vi.fn(async () => ({
+ items: [
+ {
+ resourceId: 'sub-1',
+ rid: 'sub-1',
+ gfsUri: 'gfs://main/sub-1',
+ drive: 'main',
+ parentResourceId: 'folder-1',
+ name: 'Subfolder',
+ kind: 'directory',
+ path: '/Product/Subfolder',
+ version: 6,
+ bytes: 0,
+ },
+ ],
+ nextCursor: null,
+ }))
+ Object.defineProperty(window, 'clerum', {
+ configurable: true,
+ value: { gfs: { listChildren } },
+ })
+ const child = {
+ resourceId: 'child-1',
+ rid: 'child-1',
+ gfsUri: 'gfs://main/child-1',
+ drive: 'main',
+ parentResourceId: 'folder-1',
+ name: 'notes.txt',
+ kind: 'file',
+ path: '/Product/notes.txt',
+ version: 3,
+ bytes: 12,
+ }
+ hookMock.useGfsBrowserController.mockReturnValue({
+ ...baseController(),
+ current: {
+ resourceId: 'folder-1',
+ gfsUri: 'gfs://main/folder-1',
+ name: 'Product',
+ kind: 'directory',
+ version: 1,
+ bytes: 0,
+ },
+ crumbs: [
+ {
+ resourceId: 'folder-1',
+ gfsUri: 'gfs://main/folder-1',
+ name: 'Product',
+ kind: 'directory',
+ version: 1,
+ bytes: 0,
+ },
+ ],
+ items: [child],
+ moveResource,
+ })
+
+ renderFilesPage(pushToast)
+
+ await act(async () => {
+ fireEvent.click(screen.getByRole('button', { name: 'Options for notes.txt' }))
+ })
+ // Move is not affordance-gated (authority is parent-relative, server-side).
+ fireEvent.click(screen.getByRole('menuitem', { name: 'Move to…' }))
+
+ // The dialog starts at the current folder and lists its subfolders, but
+ // never the moved resource itself.
+ const dialog = await screen.findByRole('dialog', { name: 'Move file notes.txt' })
+ expect(await within(dialog).findByRole('button', { name: 'Subfolder' })).toBeTruthy()
+ expect(within(dialog).queryByRole('button', { name: 'notes.txt' })).toBeNull()
+
+ await act(async () => {
+ fireEvent.click(within(dialog).getByRole('button', { name: 'Move here (Product)' }))
+ })
+
+ expect(moveResource).toHaveBeenCalledWith('child-1', 'folder-1', 3)
+ expect(pushToast).toHaveBeenCalledWith('Moved notes.txt to Product', 'success')
+ })
+
+ it('renames a folder child from its row menu once write affordances resolve', async () => {
+ const pushToast = vi.fn()
+ const renameResource = vi.fn(async () => ({}))
+ const setRowAffordancesResourceId = vi.fn()
+ const child = {
+ resourceId: 'child-1',
+ rid: 'child-1',
+ gfsUri: 'gfs://main/child-1',
+ drive: 'main',
+ parentResourceId: 'folder-1',
+ name: 'notes.txt',
+ kind: 'file',
+ path: '/Product/notes.txt',
+ version: 3,
+ bytes: 12,
+ }
+ const controller = {
+ ...baseController(),
+ current: {
+ resourceId: 'folder-1',
+ gfsUri: 'gfs://main/folder-1',
+ name: 'Product',
+ kind: 'directory',
+ version: 1,
+ bytes: 0,
+ },
+ items: [child],
+ renameResource,
+ setRowAffordancesResourceId,
+ }
+ const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } })
+ hookMock.useGfsBrowserController.mockReturnValue(controller)
+ const view = render(
+ <QueryClientProvider client={queryClient}>
+ <FilesPage pushToast={pushToast} />
+ </QueryClientProvider>
+ )
+
+ await act(async () => {
+ fireEvent.click(screen.getByRole('button', { name: 'Options for notes.txt' }))
+ })
+ // While the row affordances are unresolved, Rename is not offered.
+ expect(screen.queryByRole('menuitem', { name: 'Rename' })).toBeNull()
+
+ hookMock.useGfsBrowserController.mockReturnValue({
+ ...controller,
+ rowAffordancesResourceId: 'child-1',
+ rowAffordances: {
+ held: ['read', 'write'],
+ canDelegate: false,
+ grantableBits: [],
+ canCreateShare: false,
+ },
+ })
+ await act(async () => {
+ view.rerender(
+ <QueryClientProvider client={queryClient}>
+ <FilesPage pushToast={pushToast} />
+ </QueryClientProvider>
+ )
+ })
+
+ await act(async () => {
+ fireEvent.click(screen.getByRole('menuitem', { name: 'Rename' }))
+ })
+ const dialog = screen.getByRole('dialog', { name: 'Rename resource' })
+ await act(async () => {
+ fireEvent.change(within(dialog).getByLabelText('New name'), {
+ target: { value: 'renamed-notes.txt' },
+ })
+ fireEvent.click(within(dialog).getByRole('button', { name: 'Save' }))
+ })
+
+ expect(renameResource).toHaveBeenCalledWith('child-1', 'renamed-notes.txt', 3)
+ expect(pushToast).toHaveBeenCalledWith('Renamed to renamed-notes.txt', 'success')
+ expect(screen.queryByRole('dialog', { name: 'Rename resource' })).toBeNull()
+ })
+
it('offers row delete on shared resources that carry the delete permission', async () => {
const pushToast = vi.fn()
const deleteResource = vi.fn(async () => ({}))
diff --git a/desktop-app/ui/src/styles.css b/desktop-app/ui/src/styles.css
index e452bc31d..62981c671 100644
--- a/desktop-app/ui/src/styles.css
+++ b/desktop-app/ui/src/styles.css
@@ -14560,6 +14560,56 @@ pre {
background: var(--surface-soft);
}
+/* Page-level rename confirmation (row/header menus): a narrow dialog over the
+ manage-modal overlay, so a row rename never needs the manage dialog. */
+.da-gfs-manage-dialog--confirm {
+ width: min(440px, 94vw);
+ max-height: none;
+ padding: var(--space-4) var(--space-5);
+}
+
+.da-gfs-manage-dialog--confirm .da-gfs-manage-dialog__body {
+ padding: 0;
+}
+
+/* Move-to-folder picker: full-width dialog with a scrollable folder list. */
+.da-gfs-move-dialog__list {
+ min-height: var(--space-8);
+ max-height: min(320px, 40vh);
+ display: grid;
+ align-content: start;
+ gap: var(--space-1);
+ overflow-y: auto;
+ border: 1px solid var(--border-soft);
+ border-radius: var(--radius-sm);
+ padding: var(--space-2);
+ background: var(--surface-soft);
+}
+
+.da-gfs-move-dialog__row {
+ min-width: 0;
+ display: flex;
+ align-items: center;
+ gap: var(--space-2);
+}
+
+.da-gfs-move-dialog__row-icon {
+ display: grid;
+ place-items: center;
+ color: var(--warning);
+}
+
+.da-gfs-move-dialog__row-icon svg {
+ width: var(--font-size-lg);
+ height: var(--font-size-lg);
+}
+
+.da-gfs-move-dialog__actions {
+ display: flex;
+ justify-content: flex-end;
+ gap: var(--space-2);
+}
+
.da-gfs-manage-section--actions .da-gfs-inline-form__field {
min-width: 0;
}