Skip to content

Your lightweight open-source personal agent.

14.8 KB
Raw Blame
import { useCallback, useEffect, useId, useLayoutEffect, useRef, useState } from "react";
import { useTranslation } from "react-i18next";

import { MarkdownText } from "@/components/MarkdownText";
import { ErrorTaskIcon, StopIcon } from "@/components/icons/product-icons";
import { SubagentTaskButton, useSubagentTasks } from "@/components/thread/SubagentTasks";
import { Button } from "@/components/ui/button";
import { HoverHint } from "@/components/ui/hover-hint";
import { LoadingRing } from "@/components/ui/loading-ring";
import { isActiveSubagentTask, type ObservedSubagentTask } from "@/lib/subagent-tasks";
import { useSubagentActivity } from "@/components/thread/useSubagentActivity";

function needsReview(task: ObservedSubagentTask) {
  return task.state === "error" || task.state === "incomplete" || task.state === "interrupted";
}

export function SubagentTaskDock({ inputKey = null }: { inputKey?: string | null }) {
  const context = useSubagentTasks();
  if (!context?.available || !context.tasks.length) return null;
  return <TaskDock key={context.sessionKey} allTasks={context.tasks} inputKey={inputKey} />;
}

function TaskDock({ allTasks, inputKey }: { allTasks: ObservedSubagentTask[]; inputKey: string | null }) {
  const { t } = useTranslation("common");
  const context = useSubagentTasks()!;
  const panelId = useId();
  const progressId = useId();
  const root = useRef<HTMLDivElement>(null);
  const ownedPointerDown = useRef<PointerEvent | null>(null);
  const trigger = useRef<HTMLButtonElement>(null);
  const panel = useRef<HTMLDivElement>(null);
  const content = useRef<HTMLDivElement>(null);
  const gesture = useRef<{ pointerId: number; x: number; y: number; height: number; wasOpen: boolean; dragged: boolean } | null>(null);
  const suppressClick = useRef(false);
  const [focused, setFocused] = useState(false);
  const [hovered, setHovered] = useState(false);
  const [treeMounted, setTreeMounted] = useState(false);
  const [listMaxHeight, setListMaxHeight] = useState(400);
  const [expandedHeight, setExpandedHeight] = useState(0);
  const [dragHeight, setDragHeight] = useState<number | null>(null);
  const { open, setOpen, tasks } = useSubagentActivity(allTasks, inputKey, context.detailOpen || focused || hovered || dragHeight !== null);
  const visible = tasks.length > 0;
  const running = allTasks.filter(isActiveSubagentTask).length;
  const composerInput = () => root.current?.closest(".thread-composer-stack")?.querySelector("textarea");
  const changeOpen = (next: boolean, returnFocus = false, preserveFeedback = false) => {
    if (next === open) return;
    if (next) setTreeMounted(true);
    setOpen(next, { preserveFeedback });
    if (!next && returnFocus) (running ? trigger.current : composerInput())?.focus({ preventScroll: true });
  };
  const finishExit = useCallback(() => setTreeMounted(false), []);
  const cancelGesture = () => {
    const start = gesture.current;
    if (!start) return;
    gesture.current = null;
    suppressClick.current = true;
    if (trigger.current?.hasPointerCapture(start.pointerId)) trigger.current.releasePointerCapture(start.pointerId);
    setDragHeight(null);
    changeOpen(start.wasOpen, false, true);
  };

  useLayoutEffect(() => {
    const node = trigger.current;
    if (!node) return;
    const preventNativeDrag = (event: TouchEvent) => {
      if (gesture.current && suppressClick.current) event.preventDefault();
    };
    // React touch handlers are passive; cancel native inertia only after tap slop.
    node.addEventListener("touchmove", preventNativeDrag, { passive: false });
    return () => node.removeEventListener("touchmove", preventNativeDrag);
  }, [visible]);

  useLayoutEffect(() => {
    if (!treeMounted || !root.current) return;
    const anchor = root.current;
    const composer = anchor.closest(".thread-composer-stack")!;
    const pane = anchor.closest(".thread-conversation");
    const viewport = window.visualViewport;
    const measure = () => {
      const top = Math.max(viewport?.offsetTop ?? 0, pane?.getBoundingClientRect().top ?? 0);
      const height = Math.min(448, anchor.getBoundingClientRect().bottom - top - 12);
      setListMaxHeight(Math.max(0, height - (trigger.current?.offsetHeight ?? 44) - 2));
    };
    measure();
    const observer = new ResizeObserver(measure);
    observer.observe(composer);
    if (pane) observer.observe(pane);
    viewport?.addEventListener("resize", measure);
    viewport?.addEventListener("scroll", measure);
    window.addEventListener("resize", measure);
    return () => {
      observer.disconnect();
      viewport?.removeEventListener("resize", measure);
      viewport?.removeEventListener("scroll", measure);
      window.removeEventListener("resize", measure);
    };
  }, [treeMounted]);

  useLayoutEffect(() => {
    if (!treeMounted || !content.current) return;
    const node = content.current;
    const measure = () => setExpandedHeight(node.getBoundingClientRect().height);
    measure();
    const observer = new ResizeObserver(measure);
    observer.observe(node);
    return () => observer.disconnect();
  }, [treeMounted]);

  useEffect(() => {
    if (open || dragHeight !== null || !treeMounted) return;
    const animations = panel.current?.getAnimations?.() ?? [];
    if (!animations.length) { finishExit(); return; }
    let cancelled = false;
    void Promise.allSettled(animations.map(animation => animation.finished)).then(() => {
      if (!cancelled) finishExit();
    });
    return () => { cancelled = true; };
  }, [open, dragHeight, treeMounted, finishExit]);

  useEffect(() => {
    if ((!open && dragHeight === null) || context.detailOpen) return;
    const outside = (event: PointerEvent) => {
      const target = event.target;
      if (gesture.current || ownedPointerDown.current === event || !(target instanceof Element) || root.current?.closest(".thread-composer-stack")?.contains(target)) return;
      // Dismissing on blank space must not strand focus after the last task.
      const focusable = target.closest("button, a[href], input, textarea, select, [tabindex], [contenteditable=true]");
      const returnFocus = !running && !focusable;
      if (returnFocus) event.preventDefault();
      changeOpen(false, returnFocus);
    };
    const escape = (event: KeyboardEvent) => {
      if (event.key !== "Escape" || event.isComposing || event.defaultPrevented) return;
      event.preventDefault();
      if (gesture.current) cancelGesture();
      else changeOpen(false, !!root.current?.contains(document.activeElement) || (!running && document.activeElement === document.body));
    };
    document.addEventListener("pointerdown", outside);
    window.addEventListener("keydown", escape);
    return () => {
      document.removeEventListener("pointerdown", outside);
      window.removeEventListener("keydown", escape);
    };
  });

  const completed = tasks.filter(task => task.state === "done").length;
  const attention = tasks.filter(needsReview).length;
  const progress = t("thread.subagents.progress", { completed, total: tasks.length });
  const summary = running ? t("thread.subagents.running", { count: running })
    : completed === tasks.length ? t("thread.subagents.completed", { count: completed })
      : t("thread.subagents.finished", { count: tasks.length });
  const title = t("thread.subagents.workTitle");

  if (!visible) return null;
  return <div ref={root} data-testid="subagent-task-dock" className="subagent-task-dock relative mx-auto h-11 sm:h-7"
    onPointerDownCapture={event => { ownedPointerDown.current = event.nativeEvent; }}>
    <div className="absolute inset-x-0 bottom-0 z-30 overflow-hidden rounded-t-2xl border border-b-0 border-border/70 bg-card shadow-[0_-4px_20px_rgba(15,23,42,0.06)] dark:shadow-[0_-4px_20px_rgba(0,0,0,0.24)]">
      <HoverHint enabled={!open && dragHeight === null} content={`${title} · ${summary}`}>
        <button ref={trigger} type="button" data-testid="subagent-task-dock-trigger"
          aria-expanded={open} aria-controls={panelId}
          onFocus={() => setFocused(true)} onBlur={() => setFocused(false)}
          onPointerEnter={event => { if (event.pointerType === "mouse") setHovered(true); }} onPointerLeave={() => setHovered(false)}
          onPointerDown={event => {
            if (event.button !== 0 || !event.isPrimary || gesture.current) return;
            event.currentTarget.setPointerCapture(event.pointerId);
            const height = panel.current?.getBoundingClientRect().height ?? 0;
            gesture.current = { pointerId: event.pointerId, x: event.clientX, y: event.clientY, height, wasOpen: open, dragged: false };
            suppressClick.current = false;
            setTreeMounted(true);
            setDragHeight(height);
          }}
          onPointerMove={event => {
            const start = gesture.current;
            if (!start || start.pointerId !== event.pointerId) return;
            const dy = event.clientY - start.y;
            const dx = Math.abs(event.clientX - start.x);
            suppressClick.current ||= Math.hypot(dx, dy) > 6;
            if (!start.dragged && (Math.abs(dy) <= 6 || Math.abs(dy) <= dx)) return;
            start.dragged = true;
            const height = Math.max(0, Math.min(content.current!.getBoundingClientRect().height, start.height - dy));
            if (height > 0) changeOpen(true);
            setDragHeight(height);
          }}
          onPointerUp={event => {
            const start = gesture.current;
            if (!start || start.pointerId !== event.pointerId) return;
            gesture.current = null;
            const dy = event.clientY - start.y;
            const dx = Math.abs(event.clientX - start.x);
            suppressClick.current ||= Math.hypot(dx, dy) > 6;
            event.currentTarget.releasePointerCapture(event.pointerId);
            setDragHeight(null);
            const next = start.dragged && Math.abs(dy) >= 24 ? dy < 0 : start.wasOpen;
            changeOpen(next, start.dragged && !next, !start.wasOpen && !next);
          }}
          onPointerCancel={event => { if (gesture.current?.pointerId === event.pointerId) cancelGesture(); }}
          onLostPointerCapture={event => { if (gesture.current?.pointerId === event.pointerId) cancelGesture(); }}
          onClick={event => {
            if (suppressClick.current && event.detail !== 0) { suppressClick.current = false; return; }
            changeOpen(!open, open);
          }}
          className="group flex h-11 w-full touch-none select-none items-center justify-center text-muted-foreground outline-none transition-colors hover:bg-muted/70 hover:text-foreground focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-ring active:cursor-grabbing motion-reduce:transition-none sm:h-7 sm:cursor-grab">
          <span aria-hidden className="h-1 w-8 rounded-full bg-current opacity-30 transition-opacity group-hover:opacity-60 motion-reduce:transition-none" />
          <span className="sr-only">{title} · {summary}
            {attention ? ` · ${t("thread.subagents.needsReview", { count: attention })}` : ""}
          </span>
        </button>
      </HoverHint>
      <div ref={panel} id={panelId} role="region" aria-label={title} aria-describedby={progressId}
        hidden={!treeMounted} aria-hidden={open ? undefined : true} {...(!open ? { inert: "" } : {})}
        className="overflow-hidden transition-[height] duration-200 ease-out motion-reduce:transition-none"
        style={{ height: dragHeight === null ? open ? expandedHeight : 0 : Math.min(dragHeight, expandedHeight), transition: dragHeight === null ? undefined : "none" }}>
        <p id={progressId} className="sr-only">{progress}</p>
        <div ref={content}>{treeMounted ? <TaskTree tasks={tasks} maxHeight={listMaxHeight} /> : null}</div>
      </div>
    </div>
  </div>;
}

function TaskTree({ tasks, maxHeight }: { tasks: ObservedSubagentTask[]; maxHeight: number }) {
  const { t } = useTranslation("common");
  const context = useSubagentTasks()!;
  return <div data-testid="subagent-task-tree" style={{ maxHeight }} className="min-h-0 overflow-y-auto overscroll-contain p-1.5 pt-0 scrollbar-thin">
    <ol className="space-y-0.5">
      {tasks.map(task => <li key={task.task_id} data-task-state={task.state}
        onClick={event => {
          const target = event.target;
          if (event.defaultPrevented || !(target instanceof Element) || !event.currentTarget.contains(target)
            || target.closest("button, a[href], input, textarea, select, summary, [role=button], [role=link], [contenteditable=true]")) return;
          const selection = window.getSelection();
          if (selection && !selection.isCollapsed && selection.containsNode(event.currentTarget, true)) return;
          context.open(task, event.currentTarget.querySelector<HTMLButtonElement>("[data-subagent-id]")!);
        }}
        className="cursor-pointer rounded-lg transition-colors duration-150 hover:bg-muted/50 focus-within:bg-muted/50 motion-reduce:transition-none">
        <div className="flex min-w-0 items-center gap-0.5">
          <SubagentTaskButton task={task} surface="activity" />
          {task.state === "queued" || task.state === "running" ? <HoverHint content={t("thread.subagents.stopTask", { label: task.label })}>
            <Button type="button" variant="ghost" size="icon"
              className="h-11 w-11 shrink-0 rounded-lg text-muted-foreground hover:bg-destructive/10 hover:text-destructive motion-reduce:transition-none sm:h-9 sm:w-9"
              aria-label={t("thread.subagents.stopTask", { label: task.label })} aria-busy={context.stoppingId === task.task_id}
              disabled={context.stoppingId !== null} onClick={() => void context.stop(task)}>
              {context.stoppingId === task.task_id ? <LoadingRing className="h-3.5 w-3.5" /> : <StopIcon className="h-3.5 w-3.5" fill="currentColor" aria-hidden />}
            </Button>
          </HoverHint> : null}
        </div>
        {isActiveSubagentTask(task) && task.tool_events.length ? <ul className="ml-[21px] mr-2 space-y-1 border-l border-border/60 pb-2 pl-4 text-[11px] leading-4 text-muted-foreground">
          {task.tool_events.map((tool, index) => <li key={`${index}:${tool.name}`} className="flex min-h-5 min-w-0 items-center gap-2">
            {tool.status === "error" ? <ErrorTaskIcon className="h-3 w-3 shrink-0 text-destructive" aria-hidden />
              : <span className="h-1 w-1 shrink-0 rounded-full bg-current opacity-50" aria-hidden />}
            <span className="truncate font-mono">{tool.name}</span>
          </li>)}
        </ul> : null}
        {task.error ? <p className="ml-[38px] line-clamp-2 break-words pb-2 pr-3 text-xs leading-5 text-destructive">{task.error}</p>
          : task.state === "done" && task.result ? <div className="ml-[38px] min-w-0 pb-2 pr-3">
            <MarkdownText className="text-muted-foreground [--text-reading-size:0.75rem]">{task.result}</MarkdownText>
          </div> : null}
      </li>)}
    </ol>
    {context.stopError ? <p role="alert" className="px-3 pt-2 text-xs text-destructive">{context.stopError}</p> : null}
  </div>;
}