Files
kandev/apps/web/lib/state/slices/ui/ui-slice.ts
T

625 lines
21 KiB
TypeScript

import type { StateCreator } from "zustand";
import { updateUserSettings } from "@/lib/api/domains/settings-api";
import {
getStoredCollapsedSubtaskParents,
getStoredOrderedTaskIds,
getStoredPinnedTaskIds,
getStoredSidebarActiveViewId,
getStoredSidebarDraft,
getStoredSidebarUserViews,
getStoredSubtaskOrderByParentId,
removeStoredSidebarDraft,
setLocalStorage,
setStoredCollapsedSubtaskParents,
setStoredQuickChatName,
setStoredSidebarActiveViewId,
setStoredSidebarDraft,
setStoredSidebarUserViews,
} from "@/lib/local-storage";
import { buildSidebarTaskPrefsActions } from "./sidebar-task-prefs-actions";
import { DEFAULT_ACTIVE_VIEW_ID, DEFAULT_VIEW } from "./sidebar-view-builtins";
import type {
FilterClause,
GroupKey,
SidebarView,
SidebarViewDraft,
SortSpec,
} from "./sidebar-view-types";
import { toApiSidebarView } from "./sidebar-view-wire";
import type { SystemHealthResponse } from "@/lib/types/health";
import type { ActiveDocument, UISlice, UISliceState } from "./types";
function loadSidebarState(): UISliceState["sidebarViews"] {
let views = getStoredSidebarUserViews<SidebarView[]>([]).map(migrateView);
if (views.length === 0) {
views = [DEFAULT_VIEW];
}
setStoredSidebarUserViews(views);
const storedActive = getStoredSidebarActiveViewId(DEFAULT_ACTIVE_VIEW_ID);
const activeViewId = views.some((v) => v.id === storedActive) ? storedActive : views[0].id;
const draft = getStoredSidebarDraft<SidebarViewDraft | null>(null);
return { views, activeViewId, draft, syncError: null };
}
export const KNOWN_DIMENSIONS = new Set<string>([
"archived",
"state",
"workflow",
"workflowStep",
"executorType",
"repository",
"hasDiff",
"isPRReview",
"titleMatch",
]);
export const KNOWN_SORT_KEYS = new Set<string>([
"state",
"updatedAt",
"createdAt",
"title",
"custom",
]);
// Drops clauses whose dimension is no longer known (e.g. renamed or removed in an upgrade),
// and resets stale sort keys, so the popover does not crash when rendering stored views.
export function migrateView(view: SidebarView): SidebarView {
const sort: SortSpec = KNOWN_SORT_KEYS.has(view.sort.key)
? view.sort
: { key: "state", direction: view.sort.direction };
return {
...view,
filters: view.filters.filter((c) => KNOWN_DIMENSIONS.has(c.dimension)),
sort,
};
}
function persistUserViews(views: SidebarView[]): void {
setStoredSidebarUserViews(views);
}
function makeId(prefix: string): string {
return `${prefix}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
}
function reorderViewsById(
views: SidebarView[],
activeViewId: string,
overViewId: string,
): SidebarView[] | null {
if (activeViewId === overViewId) return null;
const oldIndex = views.findIndex((v) => v.id === activeViewId);
const newIndex = views.findIndex((v) => v.id === overViewId);
if (oldIndex === -1 || newIndex === -1) return null;
const next = [...views];
const [moved] = next.splice(oldIndex, 1);
next.splice(newIndex, 0, moved);
return next;
}
export const defaultUIState: UISliceState = {
previewPanel: {
openBySessionId: {},
viewBySessionId: {},
deviceBySessionId: {},
stageBySessionId: {},
urlBySessionId: {},
urlDraftBySessionId: {},
},
rightPanel: { activeTabBySessionId: {} },
diffs: { files: [] },
connection: { status: "disconnected", error: null },
mobileKanban: { activeColumnIndex: 0, isMenuOpen: false, isSearchOpen: false },
mobileSession: { activePanelBySessionId: {}, isTaskSwitcherOpen: false },
chatInput: { planModeBySessionId: {} },
documentPanel: { activeDocumentBySessionId: {} },
systemHealth: { issues: [], checks: [], healthy: true, loaded: false, loading: false },
quickChat: { isOpen: false, sessions: [], activeSessionId: null },
configChat: { isOpen: false, sessions: [], activeSessionId: null, workspaceId: null },
sessionFailureNotification: null,
bottomTerminal: { isOpen: false, pendingCommand: null },
sidebarViews: loadSidebarState(),
collapsedSubtaskParents: [],
kanbanPreviewedTaskId: null,
sidebarTaskPrefs: { pinnedTaskIds: [], orderedTaskIds: [], subtaskOrderByParentId: {} },
};
type ImmerSet = Parameters<typeof createUISlice>[0];
function buildPreviewActions(set: ImmerSet) {
return {
setPreviewOpen: (sessionId: string, open: boolean) =>
set((draft) => {
draft.previewPanel.openBySessionId[sessionId] = open;
setLocalStorage(`preview-open-${sessionId}`, open);
}),
togglePreviewOpen: (sessionId: string) =>
set((draft) => {
const current = draft.previewPanel.openBySessionId[sessionId] ?? false;
draft.previewPanel.openBySessionId[sessionId] = !current;
setLocalStorage(`preview-open-${sessionId}`, !current);
}),
setPreviewView: (
sessionId: string,
view: UISliceState["previewPanel"]["viewBySessionId"][string],
) =>
set((draft) => {
draft.previewPanel.viewBySessionId[sessionId] = view;
setLocalStorage(`preview-view-${sessionId}`, view);
}),
setPreviewDevice: (
sessionId: string,
device: UISliceState["previewPanel"]["deviceBySessionId"][string],
) =>
set((draft) => {
draft.previewPanel.deviceBySessionId[sessionId] = device;
setLocalStorage(`preview-device-${sessionId}`, device);
}),
setPreviewStage: (
sessionId: string,
stage: UISliceState["previewPanel"]["stageBySessionId"][string],
) =>
set((draft) => {
draft.previewPanel.stageBySessionId[sessionId] = stage;
}),
setPreviewUrl: (sessionId: string, url: string) =>
set((draft) => {
draft.previewPanel.urlBySessionId[sessionId] = url;
}),
setPreviewUrlDraft: (sessionId: string, url: string) =>
set((draft) => {
draft.previewPanel.urlDraftBySessionId[sessionId] = url;
}),
};
}
function buildMobileActions(set: ImmerSet) {
return {
setMobileKanbanColumnIndex: (index: number) =>
set((draft) => {
draft.mobileKanban.activeColumnIndex = index;
}),
setMobileKanbanMenuOpen: (open: boolean) =>
set((draft) => {
draft.mobileKanban.isMenuOpen = open;
}),
setMobileKanbanSearchOpen: (open: boolean) =>
set((draft) => {
draft.mobileKanban.isSearchOpen = open;
}),
setMobileSessionPanel: (
sessionId: string,
panel: UISliceState["mobileSession"]["activePanelBySessionId"][string],
) =>
set((draft) => {
draft.mobileSession.activePanelBySessionId[sessionId] = panel;
}),
setMobileSessionTaskSwitcherOpen: (open: boolean) =>
set((draft) => {
draft.mobileSession.isTaskSwitcherOpen = open;
}),
};
}
function buildBottomTerminalActions(set: ImmerSet) {
return {
toggleBottomTerminal: () =>
set((draft) => {
const newValue = !draft.bottomTerminal.isOpen;
draft.bottomTerminal.isOpen = newValue;
setLocalStorage("bottom-terminal-open", String(newValue));
}),
openBottomTerminalWithCommand: (command: string) =>
set((draft) => {
draft.bottomTerminal.isOpen = true;
draft.bottomTerminal.pendingCommand = command;
setLocalStorage("bottom-terminal-open", "true");
}),
clearBottomTerminalCommand: () =>
set((draft) => {
draft.bottomTerminal.pendingCommand = null;
}),
};
}
// Tracks the most recent in-flight views PATCH. On failure, only the latest
// request is allowed to revert — earlier failed requests are ignored because
// their state is already stale (a newer action is in flight).
let viewsSyncRequestId = 0;
type SidebarSnapshot = {
views: SidebarView[];
activeViewId: string;
draft: SidebarViewDraft | null;
};
function snapshotSidebar(s: UISliceState["sidebarViews"]): SidebarSnapshot {
return {
views: s.views.map(cloneView),
activeViewId: s.activeViewId,
draft: s.draft ? { ...s.draft } : null,
};
}
function writeCacheFromSidebar(s: SidebarSnapshot | UISliceState["sidebarViews"]) {
persistUserViews(s.views);
setStoredSidebarActiveViewId(s.activeViewId);
if (s.draft) setStoredSidebarDraft(s.draft);
else removeStoredSidebarDraft();
}
function mutateViews(
set: ImmerSet,
get: () => UISlice,
mutate: (slice: UISliceState["sidebarViews"]) => boolean | void,
): void {
const snapshot = snapshotSidebar(get().sidebarViews);
let committed = false;
set((draft) => {
committed = mutate(draft.sidebarViews) !== false;
});
if (!committed) return;
const after = get().sidebarViews;
writeCacheFromSidebar(after);
const thisRequestId = ++viewsSyncRequestId;
updateUserSettings({ sidebar_views: after.views.map(toApiSidebarView) }).catch((err) => {
if (thisRequestId !== viewsSyncRequestId) return;
const message = err instanceof Error ? err.message : "Failed to sync sidebar views";
set((draft) => {
draft.sidebarViews.views = snapshot.views;
draft.sidebarViews.activeViewId = snapshot.activeViewId;
draft.sidebarViews.draft = snapshot.draft;
draft.sidebarViews.syncError = message;
});
writeCacheFromSidebar(snapshot);
});
}
function buildSidebarLocalActions(set: ImmerSet, get: () => UISlice) {
return {
setSidebarActiveView: (viewId: string) =>
set((draft) => {
if (!draft.sidebarViews.views.some((v) => v.id === viewId)) return;
draft.sidebarViews.activeViewId = viewId;
draft.sidebarViews.draft = null;
setStoredSidebarActiveViewId(viewId);
removeStoredSidebarDraft();
}),
updateSidebarDraft: (
patch: Partial<{ filters: FilterClause[]; sort: SortSpec; group: GroupKey }>,
) =>
set((draft) => {
const active = draft.sidebarViews.views.find(
(v) => v.id === draft.sidebarViews.activeViewId,
);
if (!active) return;
const current: SidebarViewDraft = draft.sidebarViews.draft ?? {
baseViewId: active.id,
filters: active.filters,
sort: active.sort,
group: active.group,
};
const next: SidebarViewDraft = {
baseViewId: active.id,
filters: patch.filters ?? current.filters,
sort: patch.sort ?? current.sort,
group: patch.group ?? current.group,
};
draft.sidebarViews.draft = next;
setStoredSidebarDraft(next);
}),
discardSidebarDraft: () =>
set((draft) => {
draft.sidebarViews.draft = null;
removeStoredSidebarDraft();
}),
clearSidebarSyncError: () =>
set((draft) => {
draft.sidebarViews.syncError = null;
}),
// collapsedGroups is per-device visual state; update in memory and the
// localStorage cache only. Don't PATCH — we'd flood the backend on every
// expand/collapse click, and the server-side copy is stale anyway across
// devices. The next mutateViews call picks up any newer local state.
toggleSidebarGroupCollapsed: (viewId: string, groupKey: string) => {
set((draft) => {
const view = draft.sidebarViews.views.find((v) => v.id === viewId);
if (!view) return;
const idx = view.collapsedGroups.indexOf(groupKey);
if (idx === -1) view.collapsedGroups.push(groupKey);
else view.collapsedGroups.splice(idx, 1);
});
persistUserViews(get().sidebarViews.views);
},
migrateLocalViewsToBackend: () => {
const views = get().sidebarViews.views;
const thisRequestId = ++viewsSyncRequestId;
updateUserSettings({ sidebar_views: views.map(toApiSidebarView) }).catch((err) => {
if (thisRequestId !== viewsSyncRequestId) return;
const message = err instanceof Error ? err.message : "Failed to sync sidebar views";
set((draft) => {
draft.sidebarViews.syncError = message;
});
});
},
};
}
function buildSidebarBackendActions(set: ImmerSet, get: () => UISlice) {
const mv = (mutate: (s: UISliceState["sidebarViews"]) => boolean | void) =>
mutateViews(set, get, mutate);
return {
saveSidebarDraftAs: (name: string) =>
mv((s) => {
if (!s.draft) return false;
s.views.push({
id: makeId("view"),
name: name.trim() || "Untitled view",
filters: s.draft.filters,
sort: s.draft.sort,
group: s.draft.group,
collapsedGroups: [],
});
s.activeViewId = s.views[s.views.length - 1].id;
s.draft = null;
}),
saveSidebarDraftOverwrite: () =>
mv((s) => {
if (!s.draft) return false;
const view = s.views.find((v) => v.id === s.draft!.baseViewId);
if (!view) return false;
view.filters = s.draft.filters;
view.sort = s.draft.sort;
view.group = s.draft.group;
s.draft = null;
}),
duplicateSidebarView: (viewId: string, name: string) =>
mv((s) => {
const source = s.views.find((v) => v.id === viewId);
if (!source) return false;
s.views.push({
id: makeId("view"),
name: name.trim() || `${source.name} copy`,
filters: source.filters.map((f) => ({ ...f, id: makeId("clause") })),
sort: source.sort,
group: source.group,
collapsedGroups: [],
});
s.activeViewId = s.views[s.views.length - 1].id;
}),
deleteSidebarView: (viewId: string) =>
mv((s) => {
const remaining = s.views.filter((v) => v.id !== viewId);
if (remaining.length === 0) return false;
s.views = remaining;
if (s.activeViewId === viewId) s.activeViewId = remaining[0].id;
s.draft = null;
}),
renameSidebarView: (viewId: string, name: string) =>
mv((s) => {
const view = s.views.find((v) => v.id === viewId);
if (!view) return false;
const next = name.trim();
if (!next || next === view.name) return false;
view.name = next;
}),
reorderSidebarViews: (activeViewId: string, overViewId: string) =>
mv((s) => {
const reordered = reorderViewsById(s.views, activeViewId, overViewId);
if (!reordered) return false;
s.views = reordered;
}),
};
}
function buildSidebarViewActions(set: ImmerSet, get: () => UISlice) {
return {
...buildSidebarLocalActions(set, get),
...buildSidebarBackendActions(set, get),
};
}
function cloneView(v: SidebarView): SidebarView {
return {
id: v.id,
name: v.name,
filters: v.filters.map((f) => ({ ...f })),
sort: { ...v.sort },
group: v.group,
collapsedGroups: [...v.collapsedGroups],
};
}
function buildSystemHealthActions(set: ImmerSet) {
return {
setSystemHealth: (response: SystemHealthResponse) =>
set((draft) => {
draft.systemHealth.issues = response.issues;
draft.systemHealth.checks = response.checks ?? [];
draft.systemHealth.healthy = response.healthy;
draft.systemHealth.loaded = true;
}),
setSystemHealthLoading: (loading: boolean) =>
set((draft) => {
draft.systemHealth.loading = loading;
}),
invalidateSystemHealth: () =>
set((draft) => {
draft.systemHealth.loaded = false;
}),
};
}
function buildCollapsedSubtaskActions(set: ImmerSet, get: () => UISlice) {
return {
// Tab-scoped collapse of a parent task's subtasks. Persisted via
// sessionStorage (survives reload / task switch within the tab, resets on
// tab close). Not per-view and not synced to the backend — purely visual.
toggleSubtaskCollapsed: (parentTaskId: string) => {
set((draft) => {
const list = draft.collapsedSubtaskParents;
const idx = list.indexOf(parentTaskId);
if (idx === -1) list.push(parentTaskId);
else list.splice(idx, 1);
});
setStoredCollapsedSubtaskParents(get().collapsedSubtaskParents);
},
};
}
function buildConfigChatActions(set: ImmerSet) {
return {
openConfigChat: (sessionId: string, workspaceId: string) =>
set((draft) => {
draft.configChat.isOpen = true;
draft.configChat.workspaceId = workspaceId;
const exists = draft.configChat.sessions.some((s) => s.sessionId === sessionId);
if (!exists) {
draft.configChat.sessions.push({ sessionId, workspaceId });
}
draft.configChat.activeSessionId = sessionId;
}),
startNewConfigChat: (workspaceId: string) =>
set((draft) => {
draft.configChat.isOpen = true;
draft.configChat.activeSessionId = null;
draft.configChat.workspaceId = workspaceId;
}),
closeConfigChat: () =>
set((draft) => {
draft.configChat.isOpen = false;
}),
closeConfigChatSession: (sessionId: string) =>
set((draft) => {
draft.configChat.sessions = draft.configChat.sessions.filter(
(s) => s.sessionId !== sessionId,
);
if (draft.configChat.activeSessionId === sessionId) {
if (draft.configChat.sessions.length > 0) {
const next = draft.configChat.sessions[0];
draft.configChat.activeSessionId = next.sessionId;
draft.configChat.workspaceId = next.workspaceId;
} else {
draft.configChat.activeSessionId = null;
draft.configChat.workspaceId = null;
}
}
}),
setActiveConfigChatSession: (sessionId: string) =>
set((draft) => {
draft.configChat.activeSessionId = sessionId;
}),
renameConfigChatSession: (sessionId: string, name: string) =>
set((draft) => {
const session = draft.configChat.sessions.find((s) => s.sessionId === sessionId);
if (session) {
session.name = name;
}
}),
};
}
export const createUISlice: StateCreator<UISlice, [["zustand/immer", never]], [], UISlice> = (
set,
get,
) => ({
...defaultUIState,
// Hydrate from sessionStorage at slice creation (runs in the browser, after
// the default static state) so tests and SSR both see a fresh read.
collapsedSubtaskParents: getStoredCollapsedSubtaskParents(),
sidebarTaskPrefs: {
pinnedTaskIds: getStoredPinnedTaskIds(),
orderedTaskIds: getStoredOrderedTaskIds(),
subtaskOrderByParentId: getStoredSubtaskOrderByParentId(),
},
...buildPreviewActions(set),
...buildMobileActions(set),
...buildBottomTerminalActions(set),
...buildConfigChatActions(set),
...buildSidebarViewActions(set, get),
...buildSidebarTaskPrefsActions(set),
...buildCollapsedSubtaskActions(set, get),
...buildSystemHealthActions(set),
setRightPanelActiveTab: (sessionId, tab) =>
set((draft) => {
draft.rightPanel.activeTabBySessionId[sessionId] = tab;
}),
setConnectionStatus: (status, error) =>
set((draft) => {
draft.connection.status = status;
draft.connection.error = error ?? null;
}),
setPlanMode: (sessionId, enabled) =>
set((draft) => {
draft.chatInput.planModeBySessionId[sessionId] = enabled;
}),
setActiveDocument: (sessionId, doc) =>
set((draft) => {
draft.documentPanel.activeDocumentBySessionId[sessionId] = doc;
setLocalStorage(`active-document-${sessionId}`, doc as ActiveDocument | null);
}),
setKanbanPreviewedTaskId: (taskId) =>
set((draft) => {
if (draft.kanbanPreviewedTaskId === taskId) return;
draft.kanbanPreviewedTaskId = taskId;
}),
openQuickChat: (sessionId, workspaceId, agentProfileId) =>
set((draft) => {
draft.quickChat.isOpen = true;
// If sessionId is empty, create a placeholder tab for agent selection
if (!sessionId) {
// Check if there's already an empty tab
const emptyTabExists = draft.quickChat.sessions.some((s) => s.sessionId === "");
if (!emptyTabExists) {
draft.quickChat.sessions.push({ sessionId: "", workspaceId });
}
draft.quickChat.activeSessionId = "";
return;
}
const existing = draft.quickChat.sessions.find((s) => s.sessionId === sessionId);
if (existing) {
if (agentProfileId) existing.agentProfileId = agentProfileId;
} else {
draft.quickChat.sessions.push({ sessionId, workspaceId, agentProfileId });
}
draft.quickChat.activeSessionId = sessionId;
}),
closeQuickChat: () =>
set((draft) => {
draft.quickChat.isOpen = false;
}),
closeQuickChatSession: (sessionId) =>
set((draft) => {
// Remove session from list
draft.quickChat.sessions = draft.quickChat.sessions.filter((s) => s.sessionId !== sessionId);
// If closing active session, switch to another or close modal
if (draft.quickChat.activeSessionId === sessionId) {
if (draft.quickChat.sessions.length > 0) {
draft.quickChat.activeSessionId = draft.quickChat.sessions[0].sessionId;
} else {
draft.quickChat.activeSessionId = null;
draft.quickChat.isOpen = false;
}
}
}),
setActiveQuickChatSession: (sessionId) =>
set((draft) => {
draft.quickChat.activeSessionId = sessionId;
}),
renameQuickChatSession: (sessionId, name) => {
let renamed = false;
set((draft) => {
const session = draft.quickChat.sessions.find((s) => s.sessionId === sessionId);
if (session) {
session.name = name;
renamed = true;
}
});
if (renamed) setStoredQuickChatName(sessionId, name);
},
setSessionFailureNotification: (n) =>
set((draft) => {
draft.sessionFailureNotification = n;
}),
});