import { attachSidebarTree } from "../lib/sidebarTree";
import { type EnvironmentId, type ScopedProjectRef } from "@t3tools/contracts";
import type { EnvironmentServerConfig } from "@t3tools/client-runtime/connection";
import { ThreadContextDragGhost } from "./chat/ThreadContextDragGhost";
import {
dropThreadContext,
endThreadContextDrag,
moveThreadContextDrag as moveThreadContextDragGhost,
} from "./chat/threadContextDrag";
import { discardComposerDraft } from "../lib/discardComposerDraft";
import { requestCustomSnooze } from "./CustomSnoozeDialog";
import { useAtomValue } from "@effect/atom-react";
import * as Option from "effect/Option";
import { Atom } from "effect/reactivity";
import * as Schema from "effect/Schema";
import {
DndContext,
useSensor,
useSensors,
type AutoScrollOptions,
type DragEndEvent,
type DragOverEvent,
type DragStartEvent,
type Modifier,
} from "@dnd-kit/core";
import { SortableContext } from "@dnd-kit/sortable";
import { restrictToFirstScrollableAncestor, restrictToVerticalAxis } from "@dnd-kit/modifiers";
import {
canSnooze,
effectiveSnoozed,
threadWokeAt,
} from "@t3tools/client-runtime/state/thread-settled";
import {
createInboxReturnTracker,
isThreadWorking,
} from "@t3tools/client-runtime/state/thread-inbox";
import { sortSettledThreads } from "@t3tools/client-runtime/state/thread-sort";
import {
nextShownOrder,
threadSearchMatchKey,
threadSearchSubject,
type ShownOrder,
} from "@t3tools/client-runtime/state/thread-search";
import { foldSearchQuery, rankMessageMatches } from "@t3tools/shared/paletteSearch";
import { findForMessageMatch, openThreadFindOnQuery } from "./chat/threadFindStore";
import {
threadRuntimeCanArchive,
type EnvironmentThreadShell,
} from "@t3tools/client-runtime/state/models";
import {
parseScopedThreadKey,
scopeProjectRef,
scopeThreadRef,
scopedThreadKey,
} from "@t3tools/client-runtime/environment";
import {
AuthOrchestrationOperateScope,
ProjectId,
type ScopedThreadRef,
type ThreadId,
} from "@t3tools/contracts";
import type { OlderSettledScope } from "@t3tools/client-runtime/state/threads";
import {
CheckIcon,
ChevronDownIcon,
FolderIcon,
ListFilterIcon,
PlusIcon,
SettingsIcon,
} from "lucide-react";
import {
useEffect,
useLayoutEffect,
useReducer,
useRef,
useState,
useSyncExternalStore,
type KeyboardEvent as ReactKeyboardEvent,
type MouseEvent as ReactMouseEvent,
type ReactNode,
} from "react";
import { type AnyRouter, useRouter } from "@tanstack/react-router";
import {
isAtomCommandInterrupted,
settlePromise,
squashAtomCommandFailure,
type AtomCommandResult,
} from "@t3tools/client-runtime/state/runtime";
import { isElectron } from "../env";
import {
resolveShortcutCommand,
shortcutLabelForCommand,
shouldShowThreadJumpHintsForModifiers,
threadJumpCommandForIndex,
threadJumpIndexFromCommand,
threadTraversalDirectionFromCommand,
} from "../keybindings";
import { useShortcutModifierState } from "../shortcutModifierState";
import { isTerminalFocused } from "../lib/terminalFocus";
import { isModelPickerOpen } from "../modelPickerVisibility";
import { selectThreadTerminalUiState, useTerminalUiStateStore } from "../terminalUiStateStore";
import { isMacPlatform } from "~/lib/utils";
import { readLocalApi } from "../localApi";
import { configuredHostedAppUrl } from "../hostedPairing";
import { useSidebarPendingFileDropStore } from "../sidebarPendingFileDropStore";
import {
pickableProjectGroups,
selectProjectGroupingSettings,
} from "@t3tools/client-runtime/state/project-grouping";
import {
projectGroupsSpanEnvironments,
resolveSidebarProjectScopeKeys,
getSidebarProjectSettingsKey,
type SidebarProjectSnapshot,
} from "../sidebarProjectGrouping";
import { resolveProjectExpanded, useUiStateStore } from "../uiStateStore";
import {
getThreadKeysToDeselectAfterDelete,
useThreadSelectionStore,
} from "../threadSelectionStore";
import {
canTurnThreadIntoProject,
useAcknowledgeThreadWoke,
useThreadActions,
} from "../hooks/useThreadActions";
import { useHandleNewThread } from "../hooks/useHandleNewThread";
import { useOrderWhileOpen } from "../hooks/useOrderWhileOpen";
import { useProjectPin } from "../hooks/useProjectGroupUpdate";
import { useSidebarProjectGroups } from "../hooks/useSidebarProjectGroups";
import { useTerminalFocus } from "../hooks/useTerminalFocus";
import { isCommandPaletteOpen, openCommandPalette } from "../commandPaletteBus";
import { registerSettleAndAdvance } from "../settleAndAdvance";
import { startNewThreadFromContext } from "../lib/chatThreadActions";
import { useBoringSidebarEnabled, useClientSettings } from "../hooks/useSettings";
import { useCopyToClipboard } from "../hooks/useCopyToClipboard";
import { useLocalStorage } from "../hooks/useLocalStorage";
import { useNowMinute } from "../hooks/useNowMinute";
import {
useEnvironmentIdentities,
useConnectedEnvironmentIds,
useEnvironmentMachines,
usePrimaryEnvironmentId,
} from "../state/environments";
import {
readThreadShell,
useAllEnvironmentProjectSnapshotsReady,
useDelegatedUnderParent,
useProjects,
useServerConfigs,
useQuietThreadShells,
} from "../state/entities";
import { environmentPresentations } from "../state/presentation";
import { primaryServerKeybindingsAtom } from "../state/server";
import { environmentProjects } from "../state/projects";
import { threadEnvironment } from "../state/threads";
import { useOlderSettledShelf, useOlderSettledShelfGrowth } from "../state/olderSettledShelf";
import { useThreadSearch } from "../state/queries";
import { useOrchestrationCommand } from "../state/use-orchestration-command";
import { readEnvironmentScope, useEnvironmentScope } from "../state/session";
import { appAtomRegistry } from "../rpc/atomRegistry";
import { canShareWithGuestAtom } from "./chat/guestShareAvailability";
import { openGuestShareDialog } from "./chat/guestShareDialogState";
import {
buildThreadRouteParams,
resolveActiveThreadRouteRef,
resolveThreadRouteTarget,
} from "../threadRoutes";
import type { SidebarThreadSummary } from "../types";
import { isScratchProject } from "@t3tools/client-runtime/state/projects";
import { cn } from "~/lib/utils";
import { ProjectEnvironmentBadge } from "./ProjectEnvironmentBadge";
import { ProjectRowActions } from "./ProjectComboboxRow";
import {
buildDraftActionMenuItems,
buildThreadActionMenuItems,
threadActionRequiresOperate,
} from "./threadActionMenu.logic";
import {
applySidebarThreadDrop,
filterSidebarV2VisibleThreads,
groupSidebarThreadsByProject,
sidebarFolderExpansionKeys,
buildBulkTitleRegenerationContextMenuItem,
buildBulkUnpinContextMenuItem,
deleteSelectedThreadEntries,
filterSidebarProjectScopeItems,
firstValidTimestampMs,
isSidebarNestedLinkClick,
isTrailingDoubleClick,
orderItemsByPreferredIds,
planSidebarThreadDrop,
reduceSidebarProjectScopeMenuState,
resolveAdjacentThreadId,
resolveSidebarSweepKeys,
resolveSidebarDropTarget,
resolveSidebarDropVerb,
resolveSidebarThreadSection,
resolveSidebarReorderableThreadKeys,
searchSidebarThreads,
shouldCreateNewThreadInCurrentProject,
shouldNavigateAfterThreadPark,
sidebarListItemId,
sidebarThreadKeyAtY,
sortInboxThreadsByReturn,
sortPinnedThreadsForSidebar,
sortThreadsForSidebar,
sortWorkingThreadsBySend,
useSnoozeWakeClock,
useThreadJumpHintsVisible,
type SidebarListItem,
type SidebarSection,
resolveSidebarRowThreadId,
} from "./Sidebar.logic";
import {
createSidebarCollisionDetection,
createSidebarSortingStrategy,
restrictBelowSidebarLabel,
} from "./Sidebar.drag";
import { SidebarPointerSensor } from "./Sidebar.pointer";
import { createSidebarListMotion } from "./Sidebar.motion";
import {
pickSnoozePreset,
resolveSnoozePresets,
snoozeWakeLabel,
type SnoozePreset,
} from "./Sidebar.snooze";
import { ProjectFavicon } from "./ProjectFavicon";
import { deriveProviderEntriesByEnvironment } from "../providerInstances";
import { useStableCallback } from "../hooks/useStableCallback";
import {
resolveSidebarRouteReveal,
type SidebarRouteReveal,
useActiveRowReveal,
} from "./sidebar/routeReveal";
import { stackedThreadToast, toastManager } from "./ui/toast";
import { copyThreadReference } from "../lib/copyThreadReference";
import { threadChipCopyTarget } from "@t3tools/client-runtime/thread-reference";
import { Button } from "./ui/button";
import { isProjectPinShortcut, ProjectPinButton } from "./ProjectPinButton";
import {
Combobox,
ComboboxEmpty,
ComboboxSearchInput,
ComboboxItem,
ComboboxList,
ComboboxPopup,
ComboboxTrigger,
useComboboxFilter,
} from "./ui/combobox";
import { SidebarContent, SidebarGroup, useSidebar } from "./ui/sidebar";
import { SidebarChromeFooter, SidebarChromeHeader } from "./sidebar/SidebarChrome";
import { SidebarHeaderIconButton, SidebarThreadHeader } from "./sidebar/SidebarThreadHeader";
import { TooltipProvider } from "./ui/tooltip";
import { composerDraftHasUserContent, DraftId, useComposerDraftStore } from "../composerDraftStore";
import { useThreadRouteTarget } from "../hooks/useThreadRouteTarget";
import {
SidebarSearchResultRow,
SortableThreadRow,
type SidebarProviderEntry,
type SidebarSweepAction,
} from "./sidebar/SidebarThreadRow";
import { SidebarDraftBlock } from "./sidebar/SidebarDraftBlock";
import {
SidebarProjectFolderHeader,
sidebarFolderRowId,
} from "./sidebar/SidebarProjectFolderHeader";
import {
SidebarDragBoundary,
SidebarSectionHeader,
SidebarSectionPlaceholder,
} from "./sidebar/SidebarListMarkers";
function sameSidebarProviderEntries(
left: ReadonlyMap<string, SidebarProviderEntry>,
right: ReadonlyMap<string, SidebarProviderEntry>,
): boolean {
if (left.size !== right.size) return false;
for (const [instanceId, entry] of right) {
const other = left.get(instanceId);
if (
other === undefined ||
other.driverKind !== entry.driverKind ||
other.enabled !== entry.enabled ||
other.displayName !== entry.displayName ||
other.accentColor !== entry.accentColor ||
other.acpRegistryAgentId !== entry.acpRegistryAgentId ||
other.acpRegistryIconUrl !== entry.acpRegistryIconUrl ||
other.models !== entry.models
) {
return false;
}
}
return true;
}
// Resolve providers per environment because default instance ids collide across environments.
const sidebarProviderEntriesAtom = Atom.make((get) => {
const providersByEnvironment = get(environmentPresentations.providersByEnvironmentAtom);
const derived = deriveProviderEntriesByEnvironment(
[...get(environmentPresentations.serverConfigsAtom)].map(
([environmentId, config]) =>
[environmentId, providersByEnvironment.get(environmentId) ?? [], config.settings] as const,
),
);
const previous = Option.getOrNull(
get.self<ReadonlyMap<string, ReadonlyMap<string, SidebarProviderEntry>>>(),
);
const next = new Map<string, ReadonlyMap<string, SidebarProviderEntry>>();
let changed = previous === null || previous.size !== derived.size;
for (const [environmentId, entries] of derived) {
const prior = previous?.get(environmentId);
if (prior !== undefined && sameSidebarProviderEntries(prior, entries)) {
next.set(environmentId, prior);
} else {
next.set(environmentId, entries);
changed = true;
}
}
return !changed && previous !== null ? previous : next;
}).pipe(Atom.withLabel("sidebar-provider-entries"));
const EMPTY_PROVIDER_ENTRIES: ReadonlyMap<string, SidebarProviderEntry> = new Map();
const EMPTY_THREADS: readonly EnvironmentThreadShell[] = [];
const SETTLED_TAIL_INITIAL_COUNT = 10;
const SETTLED_TAIL_PAGE_COUNT = 25;
const SETTLED_SHELF_EXPANDED_KEY = "t3code:sidebar:settled-expanded";
const SNOOZED_SHELF_EXPANDED_KEY = "t3code:sidebar:snoozed-expanded";
const WORKING_SHELF_EXPANDED_KEY = "t3code:sidebar:working-expanded";
const inboxReturns = createInboxReturnTracker();
type SidebarOptimisticDrop = {
readonly key: string;
readonly sourceSection: SidebarSection;
readonly section: "pinned" | "active" | "settled";
readonly occurredAt: string;
readonly clearsSnooze: boolean;
readonly order: readonly string[] | null;
readonly keysAtDrop: ReadonlyMap<string, string | null>;
readonly assignedKeys: ReadonlyMap<string, string>;
};
interface SidebarThreadPartitionInput {
readonly threads: readonly EnvironmentThreadShell[];
readonly scopedProjectKeys: ReadonlySet<string> | null;
/** Tasks linked environments run for a listed thread; they show under it. */
readonly delegatedUnderParent: ReadonlySet<string>;
readonly serverConfigs: ReadonlyMap<EnvironmentId, EnvironmentServerConfig>;
readonly connectedEnvironmentIds: readonly EnvironmentId[];
readonly optimisticDrop: SidebarOptimisticDrop | null;
readonly workingShelfEnabled: boolean;
/** Boring mode: folders list active threads by the user's latest message. */
readonly sortActiveBySend: boolean;
// Snooze wakes, the queued-turn grace and the Working shelf's exit grace depend
// on the clock, so the minute tick, the precise snooze-wake tick and the inbox
// tracker's expiry version are inputs: a new key repartitions.
readonly clockKey: string;
}
function scrollSidebarToTop(content: HTMLElement | null) {
content?.closest("[data-slot=scroll-area-viewport]")?.scrollTo({ top: 0 });
}
function threadShellKey(thread: Pick<SidebarThreadSummary, "environmentId" | "id">): string {
return scopedThreadKey(scopeThreadRef(thread.environmentId, thread.id));
}
const NO_DRAGGED_ORDER: readonly string[] = [];
const NO_DRAGGED_ORDERS: {
readonly settledOrder: readonly string[];
readonly activeOrder: readonly string[] | undefined;
} = { settledOrder: NO_DRAGGED_ORDER, activeOrder: undefined };
function resolveDraggedOrders(input: {
readonly drag: { readonly activeKey: string; readonly occurredAt: string };
readonly threadByKey: ReadonlyMap<string, EnvironmentThreadShell>;
readonly settledThreads: readonly EnvironmentThreadShell[];
readonly activeThreads: readonly EnvironmentThreadShell[];
readonly workingShelfEnabled: boolean;
}): typeof NO_DRAGGED_ORDERS {
const { drag, threadByKey, settledThreads, activeThreads, workingShelfEnabled } = input;
const thread = threadByKey.get(drag.activeKey);
if (thread === undefined) return NO_DRAGGED_ORDERS;
const others = (list: readonly EnvironmentThreadShell[]) =>
list.filter((candidate) => threadShellKey(candidate) !== drag.activeKey);
return {
settledOrder: sortSettledThreads([
...others(settledThreads),
applySidebarThreadDrop(thread, "settled", drag.occurredAt),
]).map(threadShellKey),
activeOrder: workingShelfEnabled
? sortInboxThreadsByReturn(
[...others(activeThreads), applySidebarThreadDrop(thread, "active", drag.occurredAt)],
inboxReturns.returnedAt,
).map(threadShellKey)
: undefined,
};
}
function routeThreadOnly(
threads: readonly EnvironmentThreadShell[],
routeThreadKey: string | null,
): readonly EnvironmentThreadShell[] {
if (routeThreadKey === null) return EMPTY_THREADS;
const routeThread = threads.find((thread) => threadShellKey(thread) === routeThreadKey);
return routeThread === undefined ? EMPTY_THREADS : [routeThread];
}
// Separate hooks cache maps independently of later Sidebar hooks and preserve dnd-kit inputs.
function useSidebarThreads(input: {
readonly projectScopeKey: string | null;
readonly scopedProjectKeys: ReadonlySet<string> | null;
readonly serverConfigs: ReadonlyMap<EnvironmentId, EnvironmentServerConfig>;
readonly connectedEnvironmentIds: readonly EnvironmentId[];
readonly optimisticDrop: SidebarOptimisticDrop | null;
readonly threads: readonly EnvironmentThreadShell[];
readonly delegatedUnderParent: ReadonlySet<string>;
readonly routeRowThreadKey: string | null;
// Set in boring mode: the project groups to fold active threads into, in order.
readonly folderGroups: readonly SidebarProjectSnapshot[] | null;
// Keeps folders with no active threads, so a project the user filtered to or pinned can start one.
readonly keepEmptyFolders: (group: SidebarProjectSnapshot) => boolean;
}) {
const {
projectScopeKey,
scopedProjectKeys,
serverConfigs,
connectedEnvironmentIds,
optimisticDrop,
threads,
delegatedUnderParent,
routeRowThreadKey,
folderGroups,
keepEmptyFolders: keepEmpty,
} = input;
// Folders already separate the work, so boring mode has no Working shelf.
const workingShelfEnabled =
useClientSettings((s) => s.sidebarWorkingShelfEnabled) && folderGroups === null;
const inboxReturnsVersion = useSyncExternalStore(
inboxReturns.subscribe,
inboxReturns.getSnapshot,
);
const nowMinute = useNowMinute();
// Minute-quantized clocks would delay second-precise snooze wakes by up to a minute.
const snoozeWakeClock = useSnoozeWakeClock(threads);
const [settledShelfExpanded, setSettledShelfExpanded] = useLocalStorage(
SETTLED_SHELF_EXPANDED_KEY,
false,
Schema.Boolean,
);
const [snoozedShelfExpanded, setSnoozedShelfExpanded] = useLocalStorage(
SNOOZED_SHELF_EXPANDED_KEY,
false,
Schema.Boolean,
);
const [workingShelfExpanded, setWorkingShelfExpanded] = useLocalStorage(
WORKING_SHELF_EXPANDED_KEY,
false,
Schema.Boolean,
);
// Shared with the old per-project sidebar, so folders keep their open state.
const projectExpandedById = useUiStateStore((store) => store.projectExpandedById);
const setProjectExpanded = useUiStateStore((store) => store.setProjectExpanded);
const [settledTail, setSettledTail] = useState({
scopeKey: projectScopeKey,
count: SETTLED_TAIL_INITIAL_COUNT,
});
if (settledTail.scopeKey !== projectScopeKey) {
setSettledTail({ scopeKey: projectScopeKey, count: SETTLED_TAIL_INITIAL_COUNT });
}
const settledVisibleCount =
settledTail.scopeKey === projectScopeKey ? settledTail.count : SETTLED_TAIL_INITIAL_COUNT;
const partition = partitionSidebarThreads({
threads,
scopedProjectKeys,
delegatedUnderParent,
serverConfigs,
connectedEnvironmentIds,
optimisticDrop,
workingShelfEnabled,
sortActiveBySend: folderGroups !== null,
clockKey: `${nowMinute}:${snoozeWakeClock}:${inboxReturnsVersion}`,
});
const { pinnedThreads, activeThreads, workingThreads, snoozedThreads, settledThreads } =
partition;
// Older settled threads load in pages; the shelf lists them only as far as they are loaded.
const olderSettledShelf = useOlderSettledShelf({
scopes: olderSettledScopes([...serverConfigs.keys()], scopedProjectKeys),
expanded: settledShelfExpanded,
visibleCount: settledVisibleCount,
});
const listedSettledThreads = settledThreads.filter(olderSettledShelf.isListed);
useOlderSettledShelfGrowth(olderSettledShelf, listedSettledThreads);
const settledCount =
settledThreads.length + olderSettledShelf.unloadedCount(partition.visibleThreads);
const visibleSettledThreads = (() => {
const visible = listedSettledThreads.slice(0, settledVisibleCount);
if (
routeRowThreadKey !== null &&
!visible.some((thread) => threadShellKey(thread) === routeRowThreadKey)
) {
const routeThread = settledThreads.find(
(thread) => threadShellKey(thread) === routeRowThreadKey,
);
if (routeThread !== undefined) visible.push(routeThread);
}
return visible.length === settledThreads.length ? settledThreads : visible;
})();
const renderedSettledThreads = settledShelfExpanded
? visibleSettledThreads
: routeThreadOnly(visibleSettledThreads, routeRowThreadKey);
const visibleSnoozedThreads = snoozedShelfExpanded
? snoozedThreads
: routeThreadOnly(snoozedThreads, routeRowThreadKey);
const visibleWorkingThreads = workingShelfExpanded
? workingThreads
: routeThreadOnly(workingThreads, routeRowThreadKey);
const projectFolders =
folderGroups === null
? null
: groupSidebarThreadsByProject(folderGroups, activeThreads, keepEmpty).map((folder) => {
const collapsed = !resolveProjectExpanded(
projectExpandedById,
sidebarFolderExpansionKeys(folder.group),
);
return {
group: folder.group,
collapsed,
// A closed folder still shows the open thread, and hints at the rest.
threads: collapsed
? routeThreadOnly(folder.threads, routeRowThreadKey)
: folder.threads,
hiddenThreads: collapsed
? folder.threads.filter((thread) => threadShellKey(thread) !== routeRowThreadKey)
: EMPTY_THREADS,
};
});
const orderedThreads = [
...pinnedThreads,
...(projectFolders === null
? activeThreads
: projectFolders.flatMap((folder) => folder.threads)),
...visibleWorkingThreads,
...visibleSnoozedThreads,
...renderedSettledThreads,
];
const sectionByThreadKey = new Map<string, SidebarSection>();
for (const [list, section] of [
[pinnedThreads, "pinned"],
[activeThreads, "active"],
[workingThreads, "working"],
[snoozedThreads, "snoozed"],
[settledThreads, "settled"],
] as const) {
for (const thread of list) sectionByThreadKey.set(threadShellKey(thread), section);
}
return {
...partition,
threads,
workingShelfEnabled,
searchableThreads: [
...pinnedThreads,
...activeThreads,
...workingThreads,
...snoozedThreads,
...settledThreads,
],
settledVisibleCount,
settledCount,
olderSettledShelf,
hiddenSettledCount: Math.max(0, settledCount - visibleSettledThreads.length),
showMoreSettled: () =>
setSettledTail((current) => ({
scopeKey: current.scopeKey,
count: current.count + SETTLED_TAIL_PAGE_COUNT,
})),
settledShelfExpanded,
toggleSettledShelf: () => setSettledShelfExpanded((value) => !value),
snoozedShelfExpanded,
toggleSnoozedShelf: () => setSnoozedShelfExpanded((value) => !value),
workingShelfExpanded,
toggleWorkingShelf: () => setWorkingShelfExpanded((value) => !value),
projectFolders,
toggleProjectFolder: (group: SidebarProjectSnapshot) => {
const keys = sidebarFolderExpansionKeys(group);
setProjectExpanded(keys, !resolveProjectExpanded(projectExpandedById, keys));
},
renderedSettledThreads,
visibleSnoozedThreads,
visibleWorkingThreads,
orderedThreadKeys: orderedThreads.map(threadShellKey),
threadByKey: new Map(orderedThreads.map((thread) => [threadShellKey(thread), thread] as const)),
settledThreadKeys: new Set(settledThreads.map(threadShellKey)),
snoozedThreadKeys: new Set(snoozedThreads.map(threadShellKey)),
sectionByThreadKey,
pinnedKeys: pinnedThreads.map(threadShellKey),
activeKeys: activeThreads.map(threadShellKey),
pinnedKeysById: new Map(
threads.map((thread) => [threadShellKey(thread), thread.pinOrderKey ?? null] as const),
),
activeKeysById: new Map(
threads.map((thread) => [threadShellKey(thread), thread.activeOrderKey ?? null] as const),
),
};
}
function partitionSidebarThreads(input: SidebarThreadPartitionInput) {
const {
threads,
scopedProjectKeys,
delegatedUnderParent,
serverConfigs,
optimisticDrop,
workingShelfEnabled,
sortActiveBySend,
} = input;
const preciseNow = new Date().toISOString();
const visible = filterSidebarV2VisibleThreads(threads, scopedProjectKeys, delegatedUnderParent);
const inboxObservation = inboxReturns.observe(workingShelfEnabled ? threads : null);
const pinned: EnvironmentThreadShell[] = [];
const active: EnvironmentThreadShell[] = [];
const working: EnvironmentThreadShell[] = [];
const inbox = (thread: EnvironmentThreadShell, manuallyMoved = false) =>
workingShelfEnabled &&
(manuallyMoved ? isThreadWorking(thread) : inboxObservation.isWorking(thread))
? working
: active;
const snoozed: EnvironmentThreadShell[] = [];
const settled: EnvironmentThreadShell[] = [];
const { draggableThreadKeys, activeReorderableThreadKeys } = resolveSidebarReorderableThreadKeys({
threads: visible,
serverConfigs,
connectedEnvironmentIds: input.connectedEnvironmentIds,
});
for (const thread of visible) {
const configLoaded = serverConfigs.has(thread.environmentId);
const threadKey = scopedThreadKey(scopeThreadRef(thread.environmentId, thread.id));
if (optimisticDrop?.key === threadKey) {
const projected = applySidebarThreadDrop(
thread,
optimisticDrop.section,
optimisticDrop.occurredAt,
optimisticDrop.assignedKeys.get(threadKey),
);
(optimisticDrop.section === "pinned"
? pinned
: optimisticDrop.section === "settled"
? settled
: inbox(projected, true)
).push(
optimisticDrop.clearsSnooze
? projected
: { ...projected, snoozedAt: thread.snoozedAt, snoozedUntil: thread.snoozedUntil },
);
} else {
const section = resolveSidebarThreadSection({
snoozed: configLoaded && effectiveSnoozed(thread, { now: preciseNow }),
settled: configLoaded && thread.settledOverride === "settled",
pinned: thread.pinnedAt != null,
});
(section === "snoozed"
? snoozed
: section === "settled"
? settled
: section === "pinned"
? pinned
: inbox(thread)
).push(thread);
}
}
// Availability gates dragging only; sorting must stay consistent across clients.
const sortedPinned = sortPinnedThreadsForSidebar(pinned);
const sortedActive = sortActiveBySend
? sortWorkingThreadsBySend(active)
: workingShelfEnabled
? sortInboxThreadsByReturn(active, inboxObservation.returnedAt)
: sortThreadsForSidebar(active);
return {
pinnedThreads:
optimisticDrop?.section !== "pinned" || optimisticDrop.order === null
? sortedPinned
: orderItemsByPreferredIds({
items: sortedPinned,
preferredIds: optimisticDrop.order,
getId: (thread) => scopedThreadKey(scopeThreadRef(thread.environmentId, thread.id)),
}),
draggableThreadKeys,
activeReorderableThreadKeys,
activeThreads:
optimisticDrop?.section !== "active" || optimisticDrop.order === null
? sortedActive
: orderItemsByPreferredIds({
items: sortedActive,
preferredIds: optimisticDrop.order,
getId: (thread) => scopedThreadKey(scopeThreadRef(thread.environmentId, thread.id)),
}),
workingThreads: sortWorkingThreadsBySend(working),
snoozedThreads: snoozed.toSorted(
(left, right) =>
firstValidTimestampMs(left.snoozedUntil ?? null) -
firstValidTimestampMs(right.snoozedUntil ?? null),
),
settledThreads: sortSettledThreads(settled),
visibleThreads: visible,
snoozeNow: preciseNow,
};
}
/** The sidebar's scope per environment: the scoped projects there, or every project. */
function olderSettledScopes(
environmentIds: ReadonlyArray<EnvironmentId>,
scopedProjectKeys: ReadonlySet<string> | null,
): ReadonlyArray<OlderSettledScope> {
if (scopedProjectKeys === null) {
return environmentIds.map((environmentId) => ({ environmentId, projectIds: null }));
}
return environmentIds.flatMap((environmentId) => {
const prefix = `${environmentId}:`;
const projectIds = [...scopedProjectKeys].flatMap((key) =>
key.startsWith(prefix) ? [ProjectId.make(key.slice(prefix.length))] : [],
);
return projectIds.length === 0 ? [] : [{ environmentId, projectIds }];
});
}
function isOptimisticDropReleased(input: {
readonly optimisticDrop: SidebarOptimisticDrop;
readonly threads: readonly EnvironmentThreadShell[];
readonly pinnedKeys: readonly string[];
readonly activeKeys: readonly string[];
readonly now: string;
}): boolean {
const { optimisticDrop, threads, pinnedKeys, activeKeys, now } = input;
const canonicalByKey = new Map(
threads.map((thread) => [
scopedThreadKey(scopeThreadRef(thread.environmentId, thread.id)),
thread,
]),
);
const thread = canonicalByKey.get(optimisticDrop.key);
if (thread === undefined || thread.archivedAt !== null) {
return true;
}
const canonicalSection = effectiveSnoozed(thread, { now })
? "snoozed"
: thread.settledOverride === "settled"
? "settled"
: thread.pinnedAt != null
? "pinned"
: "active";
if (
canonicalSection !== optimisticDrop.sourceSection &&
canonicalSection !== optimisticDrop.section
) {
return true;
}
if (optimisticDrop.order === null) {
// Settle emits unpin/unsnooze too; hold projected fields and sort times until the whole move completes.
if (
canonicalSection === optimisticDrop.section &&
thread.pinnedAt == null &&
(!optimisticDrop.clearsSnooze || thread.snoozedUntil == null)
) {
return true;
}
return false;
}
if (canonicalSection !== optimisticDrop.section) return false;
if (optimisticDrop.clearsSnooze && thread.snoozedUntil != null) return false;
const destinationKeys = optimisticDrop.section === "pinned" ? pinnedKeys : activeKeys;
const canonicalDestination = destinationKeys.flatMap((key) => {
const canonical = canonicalByKey.get(key);
return canonical === undefined ? [] : [canonical];
});
const keyByThread = new Map(
canonicalDestination.map((thread) => [
scopedThreadKey(scopeThreadRef(thread.environmentId, thread.id)),
(optimisticDrop.section === "pinned" ? thread.pinOrderKey : thread.activeOrderKey) ?? null,
]),
);
const heldOrder = optimisticDrop.order;
const heldKeys = new Set(heldOrder);
const membershipChanged =
destinationKeys.length !== heldOrder.length ||
destinationKeys.some((key) => !heldKeys.has(key));
const foreignKeyLanded = destinationKeys.some((threadKey) => {
const currentKey = keyByThread.get(threadKey) ?? null;
if (currentKey === (optimisticDrop.keysAtDrop.get(threadKey) ?? null)) return false;
return currentKey !== optimisticDrop.assignedKeys.get(threadKey);
});
const allAssignmentsLanded = [...optimisticDrop.assignedKeys].every(
([threadKey, orderKey]) => keyByThread.get(threadKey) === orderKey,
);
return membershipChanged || foreignKeyLanded || allAssignmentsLanded;
}
// Build maps in a hook so the compiler can prove they are frozen and cache them.
function useSidebarLookups() {
const projects = useProjects();
const environments = useEnvironmentIdentities();
const serverConfigs = useServerConfigs();
const providerEntriesByEnvironment = useAtomValue(sidebarProviderEntriesAtom);
const projectGroups = useSidebarProjectGroups();
const environmentLabelById = new Map(
environments.map((environment) => [environment.environmentId, environment.label] as const),
);
const projectByKey = new Map(
projects.map((project) => [`${project.environmentId}:${project.id}`, project] as const),
);
const projectDisplayNameByKey = new Map(
projectGroups.flatMap((group) =>
group.memberProjects.map(
(project) => [`${project.environmentId}:${project.id}`, group.displayName] as const,
),
),
);
const projectGroupByScopeKey = new Map(
projectGroups.map((project) => [project.projectKey, project] as const),
);
const projectScopeItems = [
{ value: "all", label: "All projects" },
...pickableProjectGroups(projectGroups).map((project) => ({
value: project.projectKey,
label: project.displayName,
})),
];
return {
projects,
serverConfigs,
projectGroups,
environmentLabelById,
providerEntriesByEnvironment,
projectByKey,
projectDisplayNameByKey,
projectGroupByScopeKey,
projectScopeItems,
};
}
function ProjectScopeRowIcon(props: { isSelected: boolean; children: ReactNode }) {
return (
<span className="relative flex shrink-0">
{props.children}
{props.isSelected ? (
<span className="pointer-events-none absolute -right-1 -bottom-1 grid size-3 place-items-center rounded-full bg-primary ring-2 ring-popover">
<CheckIcon className="size-2 text-primary-foreground" strokeWidth={4} aria-hidden />
</span>
) : null}
</span>
);
}
function canOperateThreads(
threads: ReadonlyArray<Pick<SidebarThreadSummary, "environmentId">>,
): boolean {
return threads.every((thread) =>
readEnvironmentScope(thread.environmentId, AuthOrchestrationOperateScope),
);
}
function checkThreadOperations(
threads: ReadonlyArray<Pick<SidebarThreadSummary, "environmentId">>,
): boolean {
if (canOperateThreads(threads)) return true;
toastManager.add({
type: "error",
title: "Thread action unavailable",
description: "This connection cannot change one or more selected threads.",
});
return false;
}
const SIDEBAR_DRAG_DISTANCE = 6;
// dnd-kit's 20% edge zone at full speed runs the list away while the pointer rests near the bottom.
const SIDEBAR_AUTO_SCROLL: AutoScrollOptions = { threshold: { x: 0, y: 0.05 }, acceleration: 3 };
const SIDEBAR_DRAG_LABEL_HEIGHT = 24;
const threadSearchResultId = (index: number) => `sidebar-thread-search-result-${index}`;
// Continuations that outlive a render read the open thread from the router.
function readRouteThreadKey(router: AnyRouter): string | null {
const target = resolveThreadRouteTarget(router.state.matches.at(-1)?.params ?? {});
const draft =
target?.kind === "draft"
? useComposerDraftStore.getState().getDraftSession(target.draftId)
: null;
const ref = resolveActiveThreadRouteRef(target, draft);
return ref === null ? null : scopedThreadKey(ref);
}
export default function Sidebar({ routeReveal }: { routeReveal: SidebarRouteReveal }) {
const {
projects,
serverConfigs,
projectGroups,
environmentLabelById,
providerEntriesByEnvironment,
projectByKey,
projectDisplayNameByKey,
projectGroupByScopeKey,
projectScopeItems: lookupProjectScopeItems,
} = useSidebarLookups();
const delegatedUnderParent = useDelegatedUnderParent();
const router = useRouter();
const { isMobile, setOpenMobile } = useSidebar();
const keybindings = useAtomValue(primaryServerKeybindingsAtom);
const confirmThreadDelete = useClientSettings((s) => s.confirmThreadDelete);
const confirmThreadArchive = useClientSettings((s) => s.confirmThreadArchive);
const timestampFormat = useClientSettings((s) => s.timestampFormat);
const projectGroupingSettings = useClientSettings(selectProjectGroupingSettings);
const {
settleThread,
unsettleThread,
snoozeThread,
unsnoozeThread,
pinThread,
unpinThread,
confirmAndUnpinThread,
setThreadAutoSettle,
turnThreadIntoProject,
reorderPinnedThread,
reorderActiveThread,
markThreadUnread,
archiveThread,
deleteThread,
} = useThreadActions();
const updateThreadMetadata = useOrchestrationCommand(threadEnvironment.updateMetadata, {
reportFailure: false,
});
const { copyToClipboard: copyPathToClipboard } = useCopyToClipboard<{ path: string }>({
onCopy: ({ path }) => {
toastManager.add({
type: "success",
title: "Path copied",
description: path,
});
},
onError: (error) => {
toastManager.add(
stackedThreadToast({
type: "error",
title: "Failed to copy path",
description: error instanceof Error ? error.message : "An error occurred.",
}),
);
},
});
const { copyToClipboard: copyBranchToClipboard } = useCopyToClipboard<{ branch: string }>({
target: "branch name",
onCopy: ({ branch }) => {
toastManager.add({
type: "success",
title: "Branch copied",
description: branch,
});
},
onError: (error) => {
toastManager.add(
stackedThreadToast({
type: "error",
title: "Failed to copy branch",
description: error instanceof Error ? error.message : "An error occurred.",
}),
);
},
});
const { copyToClipboard: copyThreadIdToClipboard } = useCopyToClipboard<{ threadId: ThreadId }>({
onCopy: ({ threadId }) => {
toastManager.add({
type: "success",
title: "Thread ID copied",
description: threadId,
});
},
onError: (error) => {
toastManager.add(
stackedThreadToast({
type: "error",
title: "Failed to copy thread ID",
description: error instanceof Error ? error.message : "An error occurred.",
}),
);
},
});
const boringSidebarEnabled = useBoringSidebarEnabled();
const legacySidebarEnabled = useClientSettings((settings) => settings.legacySidebarEnabled);
const folderRowsMultiline = useClientSettings((settings) => settings.boringSidebarMultilineRows);
const newThreadContext = useHandleNewThread();
// Row callbacks capture only the handler; the rest of the context changes with the route.
const { handleNewThread } = newThreadContext;
const primaryEnvironmentId = usePrimaryEnvironmentId();
const clearSelection = useThreadSelectionStore((s) => s.clearSelection);
const setSelectionAnchor = useThreadSelectionStore((s) => s.setAnchor);
const toggleThreadSelection = useThreadSelectionStore((s) => s.toggleThread);
const rangeSelectTo = useThreadSelectionStore((s) => s.rangeSelectTo);
const acknowledgeWoke = useAcknowledgeThreadWoke();
const routeTarget = useThreadRouteTarget();
const routeDraftThread = useComposerDraftStore((store) =>
routeTarget?.kind === "draft" ? store.getDraftSession(routeTarget.draftId) : null,
);
const environmentMachineById = useEnvironmentMachines();
const projectGroupsRef = useRef(projectGroups);
const persistedProjectScopeKeys = useUiStateStore((store) => store.sidebarProjectScopeKeys);
const setPersistedProjectScopeKeys = useUiStateStore((store) => store.setSidebarProjectScopeKeys);
const [projectScopeMenuState, dispatchProjectScopeMenu] = useReducer(
reduceSidebarProjectScopeMenuState,
{ open: false, query: "" },
);
const projectScopeFilter = useComboboxFilter();
const allProjectSnapshotsReady = useAllEnvironmentProjectSnapshotsReady();
const allProjectConfigsReady = useAtomValue(environmentProjects.projectConfigsReadyAtom);
// Safari may click after Ctrl+click opens settings; suppress that selection until the picker reopens.
const suppressNextScopeChangeRef = useRef(false);
const highlightedProjectScopeKeyRef = useRef<string | null>(null);
// Hold dropped rows until server placement is confirmed; block another pickup from replacing the hold.
const [optimisticDrop, setOptimisticDrop] = useState<SidebarOptimisticDrop | null>(null);
const threadSearchInputRef = useRef<HTMLInputElement>(null);
const [threadSearchQuery, setThreadSearchQuery] = useState("");
const [searchHighlightKey, setSearchHighlightKey] = useState<string | null>(null);
const connectedEnvironmentIds = useConnectedEnvironmentIds();
const queuePendingFileDrop = useSidebarPendingFileDropStore((s) => s.queuePendingFileDrop);
const clearPendingFileDrop = useSidebarPendingFileDropStore((s) => s.clearPendingFileDrop);
const [renamingThreadRef, setRenamingThreadRef] = useState<ScopedThreadRef | null>(null);
const canOperateRenamingThread = useEnvironmentScope(
renamingThreadRef?.environmentId ?? null,
AuthOrchestrationOperateScope,
);
// Losing operate access cancels the rename without committing the title, so
// the editor does not return and take focus when access comes back.
if (renamingThreadRef !== null && !canOperateRenamingThread) setRenamingThreadRef(null);
const renamingThreadKey =
renamingThreadRef !== null && canOperateRenamingThread
? scopedThreadKey(renamingThreadRef)
: null;
const [renamingTitle, setRenamingTitle] = useState("");
const settlingThreadKeysRef = useRef(new Set<string>());
const threadListRef = useRef<HTMLUListElement | null>(null);
const sidebarContentRef = useRef<HTMLDivElement | null>(null);
const dragLabelOffsetRef = useRef(0);
const listMotionRef = useRef<ReturnType<typeof createSidebarListMotion> | null>(null);
const [dragState, setDragState] = useState<{
readonly activeKey: string;
readonly activeSection: SidebarSection;
readonly occurredAt: string;
readonly activationY: number | null;
readonly targetSection: SidebarSection | null;
readonly contextDrag: boolean;
} | null>(null);
const dragSensorRef = useRef<SidebarPointerSensor | null>(null);
const contextDragKeyRef = useRef<string | null>(null);
const dragScrollRef = useRef<{ readonly viewport: Element; readonly top: number } | null>(null);
const [actionSweep, setActionSweep] = useState<{
action: SidebarSweepAction;
keys: ReadonlySet<string>;
} | null>(null);
const snoozingThreadKeysRef = useRef(new Set<string>());
const removeFromSelection = useThreadSelectionStore((s) => s.removeFromSelection);
const shortcutModifiers = useShortcutModifierState();
const terminalFocused = useTerminalFocus();
const openAddProjectCommandPalette = () => openCommandPalette({ open: "add-project" });
const routeThreadRef = resolveActiveThreadRouteRef(routeTarget, routeDraftThread);
const routeThreadKey = routeThreadRef ? scopedThreadKey(routeThreadRef) : null;
// A selection made under one scope can hold threads the next scope hides.
// The viewport outlives the scope and does not anchor, so a new list starts at the top.
const setProjectScopeKeys = (keys: readonly string[]) => {
clearSelection();
setPersistedProjectScopeKeys(keys);
scrollSidebarToTop(sidebarContentRef.current);
};
// A scope whose project is gone reads as all projects once every snapshot has
// loaded. The stored keys are left alone, so the scope returns with its project.
// An archived project's scope reads as all projects, matching the menu.
const scopeGroups = pickableProjectGroups(projectGroups);
const archivedProjectKeys = new Set(
projectGroups.filter((project) => project.archived).map((project) => project.projectKey),
);
const chosenProjectScopeKeys = resolveSidebarProjectScopeKeys({
groups: projectGroups,
keys: persistedProjectScopeKeys,
settings: projectGroupingSettings,
canClearMissingScope: allProjectSnapshotsReady && allProjectConfigsReady,
}).filter((key) => !archivedProjectKeys.has(key));
const chosenProjectGroups = scopeGroups.filter((project) =>
chosenProjectScopeKeys.includes(project.projectKey),
);
const chosenScopeProjectKeys =
chosenProjectGroups.length === 0
? null
: new Set(
chosenProjectGroups.flatMap((project) =>
project.memberProjectRefs.map(
(projectRef) => `${projectRef.environmentId}:${projectRef.projectId}`,
),
),
);
const threads = useQuietThreadShells();
const routeRowThreadKey =
routeThreadRef === null
? null
: scopedThreadKey(
scopeThreadRef(
routeThreadRef.environmentId,
resolveSidebarRowThreadId(
routeThreadRef.threadId,
routeThreadRef.environmentId,
threads,
),
),
);
const isSearchingThreads = threadSearchQuery.trim().length > 0;
// History, the palette and links can open a thread the scope hides or the list
// scrolled away; a remount starts at the top, so each mount scrolls to the open
// thread once. Render decides the widening, so the first frame of the new route
// already lists the row; the active row's ref callback scrolls to it.
const { widensScope: revealWidensScope } = resolveSidebarRouteReveal({
reveal: routeReveal,
routeKey: routeRowThreadKey,
isSearching: isSearchingThreads,
scopedProjectKeys: chosenScopeProjectKeys,
delegatedUnderParent,
findThread: (key) => threads.find((candidate) => threadShellKey(candidate) === key),
});
const projectScopeKeys = revealWidensScope ? [] : chosenProjectScopeKeys;
const projectScopeKey = projectScopeKeys.length === 0 ? null : projectScopeKeys.join("\n");
const toggleProjectScopeKey = (key: string) =>
setProjectScopeKeys(
projectScopeKeys.includes(key)
? projectScopeKeys.filter((candidate) => candidate !== key)
: [...projectScopeKeys, key],
);
// The widened scope outlives the reveal, so it is written back to the persisted
// scope. Route changes arrive from history, links and the palette, and only this
// component holds the project groups that decide a widening, so no single
// navigation handler can make the write.
// oxlint-disable-next-line t3code/no-unreasoned-state-sync -- writes a route reveal's widened project scope back to the persisted sidebar scope and clears selection
useEffect(() => {
if (!revealWidensScope) return;
clearSelection();
setPersistedProjectScopeKeys([]);
}, [clearSelection, revealWidensScope, setPersistedProjectScopeKeys]);
const revealActiveRow = useActiveRowReveal(routeReveal, routeRowThreadKey);
const showProjectEnvironments = projectGroupsSpanEnvironments(projectGroups);
const scratchMachineLabelFor = (
thread: Pick<SidebarThreadSummary, "environmentId" | "projectId">,
) => {
if (!showProjectEnvironments) return null;
const project = projectByKey.get(`${thread.environmentId}:${thread.projectId}`);
if (
!project ||
!isScratchProject(project, serverConfigs.get(thread.environmentId)?.scratchWorkspaceRoot)
) {
return null;
}
return environmentLabelById.get(thread.environmentId) ?? null;
};
// Pinning from a row keeps rows in place while the menu is open.
const projectScopeItems = useOrderWhileOpen(
lookupProjectScopeItems,
(item) => item.value,
projectScopeMenuState.open,
);
const selectedProjectScopeItem =
projectScopeKeys.length > 1
? null
: (projectScopeItems.find((item) => item.value === (projectScopeKeys[0] ?? "all")) ??
projectScopeItems[0]!);
const filteredProjectScopeItems = filterSidebarProjectScopeItems({
items: projectScopeItems,
query: projectScopeMenuState.query,
matches: (item, query) =>
projectScopeFilter.contains(item, query, (candidate) => candidate.label),
});
const scopedProjectGroups = revealWidensScope ? [] : chosenProjectGroups;
const scopedProjectRefs = scopedProjectGroups.flatMap((project) => project.memberProjectRefs);
const scopedProjectKeys = revealWidensScope ? null : chosenScopeProjectKeys;
const threadSearch = useThreadSearch(
connectedEnvironmentIds,
threadSearchQuery,
scopedProjectGroups.length === 0
? {}
: { projectIds: scopedProjectRefs.map((projectRef) => projectRef.projectId) },
);
const routeDraftIdForRows = routeTarget?.kind === "draft" ? routeTarget.draftId : null;
const visibleDraftSessionCount = useComposerDraftStore((store) => {
let count = 0;
for (const [draftKey, session] of Object.entries(store.draftThreadsByThreadKey)) {
if (session.promotedTo != null) {
continue;
}
if (!composerDraftHasUserContent(store.draftsByThreadKey[draftKey])) {
continue;
}
if (
scopedProjectKeys !== null &&
!scopedProjectKeys.has(`${session.environmentId}:${session.projectId}`)
) {
continue;
}
count += 1;
}
return count;
});
const openProjectSettings = useStableCallback(
(projectGroup: SidebarProjectSnapshot, projectRef?: ScopedProjectRef) => {
if (isMobile) {
setOpenMobile(false);
}
void router.navigate({
to: "/projects/$projectKey",
params: {
projectKey: getSidebarProjectSettingsKey(
projectGroup,
projectGroupingSettings,
projects,
projectRef,
),
},
});
},
);
const {
canPinProjectGroup: canPinProject,
setProjectGroupPinned,
toggleProjectGroupPin,
} = useProjectPin();
const handleProjectSettings = useStableCallback(
(
event: ReactMouseEvent<HTMLElement> | ReactKeyboardEvent<HTMLInputElement>,
projectGroup: SidebarProjectSnapshot,
) => {
event.preventDefault();
event.stopPropagation();
suppressNextScopeChangeRef.current = true;
dispatchProjectScopeMenu({ type: "project-settings-opened" });
openProjectSettings(projectGroup);
},
);
const startThreadInProjectFolder = useStableCallback((group: SidebarProjectSnapshot) => {
if (isMobile) setOpenMobile(false);
void handleNewThread(scopeProjectRef(group.environmentId, group.id));
});
const handleProjectFolderContextMenu = useStableCallback(
(group: SidebarProjectSnapshot, position: { x: number; y: number }) => {
const api = readLocalApi();
if (!api) return;
void (async () => {
const clicked = await settlePromise(() =>
api.contextMenu.show(
[
{ id: "new-thread", label: "New thread" },
{ id: "copy-path", label: "Copy path" },
...(canPinProject(group)
? [
group.pinned
? { id: "unpin", label: "Unpin project", icon: "pin-off" }
: { id: "pin", label: "Pin project", icon: "pin" },
]
: []),
{ id: "project-settings", label: "Project settings", icon: "settings" },
],
position,
),
);
if (clicked._tag === "Failure") return;
switch (clicked.value) {
case "new-thread":
startThreadInProjectFolder(group);
return;
case "copy-path":
copyPathToClipboard(group.workspaceRoot, { path: group.workspaceRoot });
return;
case "pin":
case "unpin":
setProjectGroupPinned(group, clicked.value === "pin");
return;
case "project-settings":
openProjectSettings(group);
return;
}
})();
},
);
const {
workingShelfEnabled,
pinnedThreads,
draggableThreadKeys,
activeReorderableThreadKeys,
activeThreads,
workingThreads,
snoozedThreads,
settledThreads,
snoozeNow,
searchableThreads,
settledVisibleCount,
settledCount,
olderSettledShelf,
hiddenSettledCount,
showMoreSettled,
settledShelfExpanded,
toggleSettledShelf,
snoozedShelfExpanded,
toggleSnoozedShelf,
workingShelfExpanded,
toggleWorkingShelf,
projectFolders,
toggleProjectFolder,
renderedSettledThreads,
visibleSnoozedThreads,
visibleWorkingThreads,
orderedThreadKeys,
threadByKey,
settledThreadKeys,
snoozedThreadKeys,
sectionByThreadKey,
pinnedKeys,
activeKeys,
pinnedKeysById,
activeKeysById,
} = useSidebarThreads({
projectScopeKey,
scopedProjectKeys,
serverConfigs,
connectedEnvironmentIds,
optimisticDrop,
threads,
delegatedUnderParent,
routeRowThreadKey,
folderGroups: boringSidebarEnabled
? scopedProjectGroups.length === 0
? // An archived project keeps a folder for its active threads, below the rest.
[...scopeGroups, ...projectGroups.filter((project) => project.archived)]
: scopedProjectGroups
: null,
keepEmptyFolders: (group) =>
scopedProjectGroups.length > 0 || (group.pinned && !group.archived),
});
// Ranked across environments as the palette ranks them, so one
// environment's list does not sit above another's better matches; rows
// already shown keep their places while slower environments answer.
const threadByMatchKey =
threadSearch.matches.length === 0
? null
: new Map(
searchableThreads.map((thread) => [
threadSearchMatchKey({ environmentId: thread.environmentId, threadId: thread.id }),
thread,
]),
);
const rankedServerMatches =
threadByMatchKey === null
? []
: rankMessageMatches(
threadSearch.matches,
(match) => {
const thread = threadByMatchKey.get(threadSearchMatchKey(match));
return thread ? threadSearchSubject(thread, null) : undefined;
},
foldSearchQuery(threadSearchQuery),
// oxlint-disable-next-line react/purity -- Recency ranking samples the clock when the search matches change; the compiler recomputes it only then.
Date.now(),
// A list filter, as on mobile: a pick would move rows unexplained.
{ picks: false },
);
const serverMatchByKey = new Map(
rankedServerMatches.map((match) => [threadSearchMatchKey(match), match] as const),
);
const [shownMessageOrder, setShownMessageOrder] = useState<ShownOrder | null>(null);
const messageOrder = nextShownOrder(
shownMessageOrder,
threadSearch.query,
[...serverMatchByKey.keys()],
Number.POSITIVE_INFINITY,
);
if (messageOrder !== shownMessageOrder) setShownMessageOrder(messageOrder);
const { titleMatches: threadTitleResults, contentMatches: threadContentResults } =
searchSidebarThreads(searchableThreads, threadSearchQuery, new Set(messageOrder.keys));
const threadSearchResults = [...threadTitleResults, ...threadContentResults];
// Only rows listed for their messages show one, and open find on it.
const threadSearchMatchByKey = new Map(
threadContentResults.flatMap((thread) => {
const key = threadSearchMatchKey({
environmentId: thread.environmentId,
threadId: thread.id,
});
const match = serverMatchByKey.get(key);
return match ? [[key, match] as const] : [];
}),
);
const threadSearchResultKeys = threadSearchResults.map((thread) =>
scopedThreadKey(scopeThreadRef(thread.environmentId, thread.id)),
);
// The highlight follows its thread, so rows that arrive late do not move
// it under Enter; a new query starts at the top.
const activeSearchResultIndex = Math.max(
0,
searchHighlightKey === null ? 0 : threadSearchResultKeys.indexOf(searchHighlightKey),
);
const setActiveSearchResultIndex = (index: number | ((index: number) => number)) =>
setSearchHighlightKey(
threadSearchResultKeys[
typeof index === "function" ? index(activeSearchResultIndex) : index
] ?? null,
);
const moveSearchHighlight = (step: 1 | -1) => {
const count = threadSearchResults.length;
setActiveSearchResultIndex((activeSearchResultIndex + step + count) % count);
};
const orderedThreadKeysRef = useRef(orderedThreadKeys);
// Read changing maps/sets through refs so streamed events preserve row callbacks.
const threadByKeyRef = useRef(threadByKey);
const settledThreadKeysRef = useRef(settledThreadKeys);
const snoozedThreadKeysRef = useRef(snoozedThreadKeys);
const jumpLabelByKey = (() => {
const mapping = new Map<string, string>();
for (const [index, threadKey] of orderedThreadKeys.entries()) {
const jumpCommand = threadJumpCommandForIndex(index);
if (!jumpCommand) break;
const label = shortcutLabelForCommand(keybindings, jumpCommand);
if (label) mapping.set(threadKey, label);
}
return mapping;
})();
const navigateToThread = (threadRef: ScopedThreadRef) => {
if (useThreadSelectionStore.getState().selectedThreadKeys.size > 0) {
clearSelection();
}
setSelectionAnchor(scopedThreadKey(threadRef));
if (isMobile) {
setOpenMobile(false);
}
return router.navigate({
to: "/$environmentId/$threadId",
params: buildThreadRouteParams(threadRef),
});
};
const handleThreadFileDrop = async (threadRef: ScopedThreadRef, files: File[]) => {
const dropId = queuePendingFileDrop({ threadRef, files });
const landedBefore =
router.buildLocation({
to: "/$environmentId/$threadId",
params: buildThreadRouteParams(threadRef),
}).pathname === router.state.location.pathname;
if (landedBefore) return;
try {
await navigateToThread(threadRef);
const landed =
router.buildLocation({
to: "/$environmentId/$threadId",
params: buildThreadRouteParams(threadRef),
}).pathname === router.state.location.pathname;
if (!landed) clearPendingFileDrop(dropId);
} catch {
clearPendingFileDrop(dropId);
}
};
const navigateToDraft = (draftId: DraftId) => {
clearSelection();
if (isMobile) {
setOpenMobile(false);
}
void router.navigate({ to: "/draft/$draftId", params: { draftId } });
};
const clearThreadSearch = () => {
setThreadSearchQuery("");
setSearchHighlightKey(null);
};
const selectThreadSearchResult = (thread: EnvironmentThreadShell) => {
const ref = scopeThreadRef(thread.environmentId, thread.id);
// A row listed for a message match opens find on it, as the palette does.
const match = threadSearchMatchByKey.get(
threadSearchMatchKey({ environmentId: thread.environmentId, threadId: thread.id }),
);
const query = threadSearch.query;
clearThreadSearch();
navigateToThread(ref);
if (match) openThreadFindOnQuery(scopedThreadKey(ref), findForMessageMatch(match, query));
};
const handleThreadSearchKeyDown = (event: ReactKeyboardEvent<HTMLInputElement>) => {
if (event.nativeEvent.isComposing || event.keyCode === 229) return;
if (event.key === "Escape" && isSearchingThreads) {
event.preventDefault();
event.stopPropagation();
clearThreadSearch();
return;
}
if (threadSearchResults.length === 0) return;
if (event.key === "ArrowDown") {
event.preventDefault();
moveSearchHighlight(1);
return;
}
if (event.key === "ArrowUp") {
event.preventDefault();
moveSearchHighlight(-1);
return;
}
if (event.key === "Enter") {
event.preventDefault();
const result = threadSearchResults[activeSearchResultIndex];
if (result) selectThreadSearchResult(result);
}
};
const startThreadRename = (threadRef: ScopedThreadRef, title: string) => {
if (!readEnvironmentScope(threadRef.environmentId, AuthOrchestrationOperateScope)) return;
setRenamingThreadRef(threadRef);
setRenamingTitle(title);
};
const cancelThreadRename = () => setRenamingThreadRef(null);
const commitThreadRename = (threadRef: ScopedThreadRef, title: string, originalTitle: string) => {
void (async () => {
if (!readEnvironmentScope(threadRef.environmentId, AuthOrchestrationOperateScope)) return;
const trimmed = title.trim();
setRenamingThreadRef(null);
if (trimmed.length === 0) {
toastManager.add({ type: "warning", title: "Thread title cannot be empty" });
return;
}
if (trimmed === originalTitle) return;
const result = await updateThreadMetadata({
environmentId: threadRef.environmentId,
input: { threadId: threadRef.threadId, title: trimmed },
});
if (result._tag === "Failure" && !isAtomCommandInterrupted(result)) {
const error = squashAtomCommandFailure(result);
toastManager.add(
stackedThreadToast({
type: "error",
title: "Failed to rename thread",
description: error instanceof Error ? error.message : "An error occurred.",
}),
);
}
})();
};
const handleThreadClick = (event: ReactMouseEvent, threadRef: ScopedThreadRef) => {
if (isSidebarNestedLinkClick(event.target)) return;
const isMac = isMacPlatform(navigator.platform);
const isModClick = isMac ? event.metaKey : event.ctrlKey;
const threadKey = scopedThreadKey(threadRef);
if (isModClick) {
event.preventDefault();
toggleThreadSelection(threadKey);
return;
}
if (event.shiftKey) {
event.preventDefault();
rangeSelectTo(threadKey, orderedThreadKeysRef.current);
return;
}
if (isTrailingDoubleClick(event.detail)) {
return;
}
navigateToThread(threadRef);
};
// Snapshot navigation before partition mutation; background parks use a null plan.
const planForwardNavigation = (
threadKey: string,
coParkingKeys?: ReadonlySet<string>,
): (() => void) | null => {
if (readRouteThreadKey(router) !== threadKey) return null;
const shell = threadByKeyRef.current.get(threadKey);
const orderedKeys = orderedThreadKeysRef.current;
const settledKeys = settledThreadKeysRef.current;
const snoozedKeys = snoozedThreadKeysRef.current;
const currentIndex = orderedKeys.indexOf(threadKey);
const nextCardKey =
currentIndex === -1
? null
: ([...orderedKeys.slice(currentIndex + 1), ...orderedKeys.slice(0, currentIndex)].find(
(key) => !settledKeys.has(key) && !snoozedKeys.has(key) && !coParkingKeys?.has(key),
) ?? null);
const nextThread = nextCardKey ? threadByKeyRef.current.get(nextCardKey) : null;
return nextThread
? () => navigateToThread(scopeThreadRef(nextThread.environmentId, nextThread.id))
: shell
? () => void handleNewThread(scopeProjectRef(shell.environmentId, shell.projectId))
: () => void router.navigate({ to: "/" });
};
const attemptSettle = (
threadRef: ScopedThreadRef,
opts: { coSettlingKeys?: ReadonlySet<string> } = {},
) => {
void (async () => {
const threadKey = scopedThreadKey(threadRef);
if (settlingThreadKeysRef.current.has(threadKey)) return;
settlingThreadKeysRef.current.add(threadKey);
const navigateAfterSettle = planForwardNavigation(threadKey, opts.coSettlingKeys);
const result = await settleThread(threadRef);
settlingThreadKeysRef.current.delete(threadKey);
if (result._tag === "Failure") {
if (!isAtomCommandInterrupted(result)) {
const error = squashAtomCommandFailure(result);
toastManager.add(
stackedThreadToast({
type: "error",
title: "Failed to settle thread",
description: error instanceof Error ? error.message : "An error occurred.",
}),
);
}
return;
}
if (
shouldNavigateAfterThreadPark({
threadKey,
currentThreadKey: readRouteThreadKey(router),
action: "settle",
now: new Date().toISOString(),
thread: readThreadShell(threadRef),
})
) {
navigateAfterSettle?.();
}
})();
};
// oxlint-disable-next-line t3code/no-unreasoned-state-sync -- registers this sidebar's settle handler in the module-level settleAndAdvance registry
useEffect(() => registerSettleAndAdvance(attemptSettle), [attemptSettle]);
const settleThreads = (threadKeys: readonly string[]) => {
const coSettlingKeys = new Set(threadKeys);
for (const threadKey of threadKeys) {
const thread = threadByKeyRef.current.get(threadKey);
if (!thread || thread.settledOverride === "settled") continue;
attemptSettle(scopeThreadRef(thread.environmentId, thread.id), { coSettlingKeys });
}
};
const attemptUnsettle = (threadRef: ScopedThreadRef) => {
void (async () => {
const result = await unsettleThread(threadRef);
if (result._tag === "Failure" && !isAtomCommandInterrupted(result)) {
const error = squashAtomCommandFailure(result);
toastManager.add(
stackedThreadToast({
type: "error",
title: "Failed to un-settle thread",
description: error instanceof Error ? error.message : "An error occurred.",
}),
);
}
})();
};
const attemptUnsnooze = (threadRef: ScopedThreadRef) => {
void (async () => {
const result = await unsnoozeThread(threadRef);
if (result._tag === "Failure" && !isAtomCommandInterrupted(result)) {
const error = squashAtomCommandFailure(result);
toastManager.add(
stackedThreadToast({
type: "error",
title: "Failed to wake thread",
description: error instanceof Error ? error.message : "An error occurred.",
}),
);
}
})();
};
const restrictBelowPins: Modifier = (args) =>
restrictBelowSidebarLabel(args, dragLabelOffsetRef.current);
const dndModifiers = [
restrictToVerticalAxis,
restrictBelowPins,
restrictToFirstScrollableAncestor,
];
const attachListMotionRef = (node: HTMLUListElement) => {
threadListRef.current = node;
const motion = createSidebarListMotion(node);
listMotionRef.current = motion;
motion.update(false);
return () => {
// Search replaces this list while the Sidebar stays mounted, and a drag
// whose rows are gone can never drop. The compiler memoizes this callback
// with no deps (it reads only refs), so the cleanup runs only on unmount.
dragSensorRef.current?.cancel();
motion.dispose();
if (listMotionRef.current === motion) listMotionRef.current = null;
if (threadListRef.current === node) threadListRef.current = null;