Skip to content

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

TypeScript
16.2 KB
Raw Blame
'use client'

import { useEffect, useMemo, useRef, useState } from 'react'
import { IconFolder } from '@components/Sidebar/icons'
import { IconCheck, IconChevronRight, IconX } from '@components/icons'
import { Button } from '@components/ui'
import { apiGet } from '@lib/api'
import type {
  GfsMoveDialogProps,
  MoveFolder,
  MoveTreeFolderProps,
  MoveTreePage,
  SelectedMoveDestination,
} from './types'

export type { GfsMoveDialogProps } from './types'

const DRIVE = 'main'

function foldersOnly(items: MoveFolder[], excludedIds: ReadonlySet<string>): MoveFolder[] {
  return items
    .filter(item => item.kind === 'directory' && !excludedIds.has(item.resourceId))
    .sort((left, right) => left.name.localeCompare(right.name))
}

function messageOf(error: unknown): string {
  return error instanceof Error ? error.message : String(error)
}

function TreeFolder({
  ancestors,
  expandedIds,
  folder,
  level,
  selected,
  targetId,
  onChildrenLoaded,
  onSelect,
  onToggle,
}: MoveTreeFolderProps) {
  const expanded = expandedIds.has(folder.resourceId)
  const [children, setChildren] = useState<MoveFolder[]>([])
  // The accumulated children across pages. A ref (not state) so the load
  // never merges a stale page set, and so the names reported upward are the
  // complete list this folder has shown.
  const loadedChildrenRef = useRef<MoveFolder[]>([])
  const [nextCursor, setNextCursor] = useState<string | null>(null)
  const [loaded, setLoaded] = useState(false)
  const [attempted, setAttempted] = useState(false)
  const [loading, setLoading] = useState(false)
  const [error, setError] = useState('')
  const nextAncestors = useMemo(
    () => new Set([...ancestors, folder.resourceId]),
    [ancestors, folder.resourceId]
  )
  const visibleChildren = useMemo(
    () => foldersOnly(children, new Set([targetId, ...ancestors])),
    [ancestors, children, targetId]
  )

  async function loadChildren(cursor?: string): Promise<void> {
    setAttempted(true)
    setLoading(true)
    setError('')
    try {
      const query: Record<string, string> = { drive: DRIVE }
      if (cursor) query.cursor = cursor
      const page = (await apiGet(
        `/api/v1/gfs/resources/${encodeURIComponent(folder.resourceId)}/children`,
        query
      )) as MoveTreePage
      const merged = cursor ? [...loadedChildrenRef.current, ...page.items] : page.items
      loadedChildrenRef.current = merged
      setChildren(merged)
      setNextCursor(page.nextCursor)
      setLoaded(true)
      // These are the names the folder already holds. The move ladder needs
      // them: a destination discovered only through this dialog is unknown to
      // the browser's children cache, and a blind ladder burns its attempts
      // on names that are already taken (RP-003).
      onChildrenLoaded(
        folder.resourceId,
        merged.map(item => item.name)
      )
    } catch (loadError) {
      setError(messageOf(loadError))
    } finally {
      setLoading(false)
    }
  }

  useEffect(() => {
    if (expanded && !loaded && !attempted) void loadChildren()
  }, [attempted, expanded, loaded])

  const canExpand = !loaded || loading || Boolean(nextCursor) || visibleChildren.length > 0

  return (
    <div
      aria-expanded={canExpand ? expanded : undefined}
      aria-level={level}
      aria-selected={selected?.resourceId === folder.resourceId}
      className="cu-gfs-move-dialog__tree-item"
      role="treeitem"
    >
      <div className="cu-gfs-move-dialog__tree-row">
        {canExpand ? (
          <button
            aria-expanded={expanded}
            aria-label={`${expanded ? 'Collapse' : 'Expand'} ${folder.name}`}
            className={`cu-gfs-move-dialog__tree-toggle${expanded ? ' is-expanded' : ''}`}
            onClick={() => onToggle(folder.resourceId)}
            type="button"
          >
            <IconChevronRight />
          </button>
        ) : (
          <span className="cu-gfs-move-dialog__tree-toggle-placeholder" aria-hidden="true" />
        )}
        <button
          aria-selected={selected?.resourceId === folder.resourceId}
          className="cu-gfs-move-dialog__tree-select"
          onClick={() => onSelect(folder)}
          type="button"
        >
          <span className="cu-gfs-move-dialog__tree-folder-icon" aria-hidden="true">
            <IconFolder />
          </span>
          <span className="cu-gfs-move-dialog__tree-folder-name">{folder.name}</span>
          <span className="cu-gfs-move-dialog__tree-selected-icon" aria-hidden="true">
            {selected?.resourceId === folder.resourceId ? <IconCheck /> : null}
          </span>
        </button>
      </div>
      {expanded ? (
        <div className="cu-gfs-move-dialog__tree-group" role="group">
          {loading && !loaded ? (
            <p className="cu-gfs-move-dialog__notice" role="status">
              Loading subfolders…
            </p>
          ) : null}
          {error ? (
            <div className="cu-banner cu-banner--error" role="alert">
              {error}
            </div>
          ) : null}
          {visibleChildren.map(child => (
            <TreeFolder
              ancestors={nextAncestors}
              expandedIds={expandedIds}
              folder={child}
              key={child.resourceId}
              level={level + 1}
              onChildrenLoaded={onChildrenLoaded}
              onSelect={onSelect}
              onToggle={onToggle}
              selected={selected}
              targetId={targetId}
            />
          ))}
          {nextCursor ? (
            <Button
              className="cu-gfs-move-dialog__load-more"
              loading={loading}
              onClick={() => void loadChildren(nextCursor)}
              size="sm"
            >
              Load more
            </Button>
          ) : null}
          {loaded && !loading && !error && !visibleChildren.length && !nextCursor ? (
            <p className="cu-gfs-move-dialog__notice">No subfolders.</p>
          ) : null}
        </div>
      ) : null}
    </div>
  )
}

export function GfsMoveDialog({
  target,
  initialCrumbs,
  busy = false,
  onClose,
  onMove,
}: GfsMoveDialogProps) {
  // The nearest crumb that is not the target itself is the folder that
  // already contains it (both entry paths end there). Selecting it is a
  // no-op the server accepts while visibly changing nothing, so it must not
  // be preselected and must not be committable.
  const currentParent = [...initialCrumbs]
    .reverse()
    .find(crumb => crumb.id && crumb.id !== target.resourceId)
  const currentParentId =
    typeof target.parentResourceId === 'string'
      ? target.parentResourceId
      : (currentParent?.id ?? null)
  const currentParentName =
    currentParent && currentParent.id === currentParentId
      ? currentParent.name === '/'
        ? DRIVE
        : currentParent.name
      : null
  const [selected, setSelected] = useState<SelectedMoveDestination | null>(null)
  const [expandedIds, setExpandedIds] = useState<Set<string>>(
    () => new Set(initialCrumbs.flatMap(crumb => (crumb.id ? [crumb.id] : [])))
  )
  const [rootFolders, setRootFolders] = useState<MoveFolder[]>([])
  const [rootResourceId, setRootResourceId] = useState<string | null>(null)
  const [nextCursor, setNextCursor] = useState<string | null>(null)
  const [loading, setLoading] = useState(false)
  const [loaded, setLoaded] = useState(false)
  const [error, setError] = useState('')
  // The names this dialog has observed inside each folder. The drive root's
  // own listing arrives with the tree; every other folder reports its
  // children as they load (RP-003).
  const knownChildNamesRef = useRef<Map<string, string[]>>(new Map())

  function reportChildrenLoaded(folderId: string, names: string[]): void {
    knownChildNamesRef.current.set(folderId, names)
  }

  async function loadRoots(cursor?: string): Promise<void> {
    setLoading(true)
    setError('')
    try {
      const query: Record<string, string> = { drive: DRIVE }
      if (cursor) query.cursor = cursor
      const page = (await apiGet('/api/v1/gfs/tree', query)) as MoveTreePage
      setRootFolders(previous => (cursor ? [...previous, ...page.items] : page.items))
      if (page.rootResourceId) setRootResourceId(page.rootResourceId)
      setNextCursor(page.nextCursor)
      setLoaded(true)
    } catch (loadError) {
      setError(messageOf(loadError))
    } finally {
      setLoading(false)
    }
  }

  useEffect(() => {
    void loadRoots()
  }, [])

  useEffect(() => {
    function handleKeyDown(event: KeyboardEvent): void {
      if (event.key === 'Escape' && !busy) onClose()
    }
    window.addEventListener('keydown', handleKeyDown)
    return () => window.removeEventListener('keydown', handleKeyDown)
  }, [busy, onClose])

  const visibleRoots = useMemo(
    () => foldersOnly(rootFolders, new Set([target.resourceId])),
    [rootFolders, target.resourceId]
  )

  function toggleFolder(folderId: string): void {
    setError('')
    setExpandedIds(previous => {
      const next = new Set(previous)
      if (next.has(folderId)) next.delete(folderId)
      else next.add(folderId)
      return next
    })
  }

  function selectFolder(folder: MoveFolder): void {
    setError('')
    setSelected({ resourceId: folder.resourceId, name: folder.name })
    setExpandedIds(previous => new Set(previous).add(folder.resourceId))
  }

  /**
   * The names the destination already holds, as far as this dialog knows
   * them. The drive root's listing IS the root's children; every other
   * destination reports its children while the tree loads them. A destination
   * that was never expanded is read once here, so the ladder is never seeded
   * blind — the browser's own children cache is cold for a folder only this
   * dialog discovered (RP-003).
   */
  async function destinationOccupiedNames(destination: SelectedMoveDestination): Promise<string[]> {
    if (destination.resourceId === rootResourceId) {
      return rootFolders.map(folder => folder.name)
    }
    const known = knownChildNamesRef.current.get(destination.resourceId)
    if (known) return known
    try {
      const page = (await apiGet(
        `/api/v1/gfs/resources/${encodeURIComponent(destination.resourceId)}/children`,
        { drive: DRIVE }
      )) as MoveTreePage
      const names = (page?.items ?? []).map(item => item.name)
      knownChildNamesRef.current.set(destination.resourceId, names)
      return names
    } catch {
      // The seed is an optimization, never the authority: the server's 409 is
      // what decides a collision. A failed read leaves the ladder blind but
      // the move itself intact.
      return []
    }
  }

  async function commit(): Promise<void> {
    if (!selected || busy) return
    setError('')
    try {
      const occupiedNames = await destinationOccupiedNames(selected)
      await onMove({
        resourceId: selected.resourceId,
        name: selected.name,
        occupiedNames,
      })
    } catch (moveError) {
      setError(messageOf(moveError))
    }
  }

  const isNoOpDestination = Boolean(selected && selected.resourceId === currentParentId)
  const rootSelected = Boolean(rootResourceId && selected?.resourceId === rootResourceId)

  return (
    <div
      className="cu-modal-backdrop cu-gfs-move-modal"
      role="presentation"
      onMouseDown={event => {
        if (event.target === event.currentTarget && !busy) onClose()
      }}
    >
      <section
        aria-label={`Move ${target.kind === 'directory' ? 'folder' : 'file'} ${target.name}`}
        aria-modal="true"
        className="cu-gfs-move-dialog"
        role="dialog"
      >
        <header className="cu-gfs-move-dialog__header">
          <span className="cu-gfs-move-dialog__header-icon" aria-hidden="true">
            <IconFolder />
          </span>
          <h3>Move “{target.name}”</h3>
          <Button
            aria-label="Close move dialog"
            className="cu-gfs-move-dialog__close"
            disabled={busy}
            icon
            onClick={onClose}
            variant="ghost"
          >
            <IconX />
          </Button>
        </header>

        <div className="cu-gfs-move-dialog__current-location">
          <span>Current location:</span>
          <span className="cu-gfs-move-dialog__location-pill">
            <IconFolder />
            <strong>{currentParentName ?? (currentParentId ? 'another folder' : DRIVE)}</strong>
          </span>
        </div>

        {error ? (
          <div className="cu-banner cu-banner--error cu-gfs-move-dialog__error" role="alert">
            {error}
          </div>
        ) : null}

        <div className="cu-gfs-move-dialog__tree-heading">EvenDrive</div>
        <div
          className="cu-gfs-move-dialog__tree"
          role="tree"
          aria-label="EvenDrive destination folders"
        >
          {rootResourceId && rootResourceId !== target.resourceId ? (
            <div
              aria-expanded="true"
              aria-level={1}
              aria-selected={rootSelected}
              className="cu-gfs-move-dialog__tree-item cu-gfs-move-dialog__tree-root"
              role="treeitem"
            >
              <div className="cu-gfs-move-dialog__tree-row">
                <span className="cu-gfs-move-dialog__tree-toggle-placeholder" aria-hidden="true" />
                <button
                  aria-label="main"
                  aria-selected={rootSelected}
                  className="cu-gfs-move-dialog__tree-select"
                  onClick={() =>
                    selectFolder({ resourceId: rootResourceId, name: DRIVE, kind: 'directory' })
                  }
                  type="button"
                >
                  <span className="cu-gfs-move-dialog__tree-folder-icon" aria-hidden="true">
                    <IconFolder />
                  </span>
                  <span className="cu-gfs-move-dialog__tree-folder-name">main</span>
                  <span className="cu-gfs-move-dialog__tree-selected-icon" aria-hidden="true">
                    {rootSelected ? <IconCheck /> : null}
                  </span>
                </button>
              </div>
            </div>
          ) : null}
          {loading && !loaded ? (
            <p className="cu-gfs-move-dialog__notice" role="status">
              Loading folders…
            </p>
          ) : !visibleRoots.length && !nextCursor ? (
            <p className="cu-gfs-move-dialog__notice">No folders here.</p>
          ) : (
            visibleRoots.map(folder => (
              <TreeFolder
                ancestors={new Set()}
                expandedIds={expandedIds}
                folder={folder}
                key={folder.resourceId}
                level={rootResourceId ? 2 : 1}
                onChildrenLoaded={reportChildrenLoaded}
                onSelect={selectFolder}
                onToggle={toggleFolder}
                selected={selected}
                targetId={target.resourceId}
              />
            ))
          )}
          {nextCursor ? (
            <Button
              className="cu-gfs-move-dialog__load-more"
              loading={loading}
              onClick={() => void loadRoots(nextCursor)}
              size="sm"
            >
              Load more
            </Button>
          ) : null}
        </div>

        <footer className="cu-gfs-move-dialog__footer">
          <span className="cu-gfs-move-dialog__selection" aria-live="polite">
            {selected ? (
              <>
                Move to <strong>{selected.name}</strong>
              </>
            ) : (
              'Select a destination folder'
            )}
          </span>
          <span className="cu-gfs-move-dialog__actions">
            <Button disabled={busy} onClick={onClose} variant="ghost">
              Cancel
            </Button>
            <Button
              aria-label={selected ? `Move here (${selected.name})` : 'Move'}
              disabled={!selected || isNoOpDestination}
              loading={busy}
              onClick={() => void commit()}
              variant="primary"
            >
              Move
            </Button>
          </span>
        </footer>
        {isNoOpDestination ? (
          <p className="cu-gfs-move-dialog__notice">
            {target.name} is already in {currentParentName ?? 'the folder you selected'} — pick a
            different destination.
          </p>
        ) : null}
      </section>
    </div>
  )
}