mesalogo
b90ff50f2a
Load Supervisor graphs only when opened, preserve source details on demand, reuse indexed story digests and window selection lists without losing keyboard or focus behavior. Route heavy UI reads through the existing worker, batch scoped queries and construct each publication snapshot once. Keep remote cancellation responsive during model-route cleanup, remove late routes and retain reported usage after response-cap cancellation. Preserve Telegram pending replies through polling conflicts, show delivery errors and honor the final rate-limit cooldown. Schema 62 adds lookup indexes without rewriting user content; older clients cannot open upgraded data. Large review publication still blocks Main and remains documented follow-up work. Record the future storage-service direction without performing the architecture migration. Validation: exact staged code passed isolated full tests (6212 passed, 87 skipped), typecheck and lint. Three-round source performance comparisons, SQLite migration equivalence, native Electron interaction checks and current-source Linux x64 Host validation completed; eight external text-model requests. Release note: Supervisor opens reviews without loading the entire graph, keeps long selection lists responsive and preserves details and keyboard navigation. Remote cancellation and Telegram reply recovery are more reliable; remote fixes require an Agent build containing this change.
7621 lines
272 KiB
TypeScript
7621 lines
272 KiB
TypeScript
import { MagicNotesPanel } from './MagicNotesPanel';
|
|
import { AnchoredMenu } from './AnchoredMenu';
|
|
import { useMagicNoteDraft } from './use-magic-note-draft';
|
|
import type { MagicNoteSource } from '../../shared/magic-notes-contracts';
|
|
import type { TerminalSnapshot } from "../../shared/terminal-contracts";
|
|
import LocalInferencePage from "./LocalInferencePage";
|
|
import { ApplicationMenu } from './ApplicationMenu';
|
|
import { DocumentConversationContext } from './DocumentConversationContext';
|
|
import { maximumAttachmentsPerMessage } from '../../shared/attachment-limits';
|
|
import { buildRuntimeHistory } from '../../shared/runtime-history';
|
|
import { DeviceSharingPage } from './DeviceSharingPage';
|
|
import {
|
|
ApplicationAvailability,
|
|
ApplicationCenter,
|
|
applicationDefinitions,
|
|
isApplicationEnabled,
|
|
} from "./ApplicationCenter";
|
|
import {
|
|
defaultApplicationNavigation,
|
|
type ApplicationSettings,
|
|
type ApplicationSettingsUpdate,
|
|
} from "../../shared/application-settings-contracts";
|
|
import type { ImageOperation } from "../../shared/image-generation-contracts";
|
|
import {
|
|
ChartColumn,
|
|
CheckCircle2,
|
|
ChevronUp,
|
|
CircleAlert,
|
|
Download,
|
|
Grid2X2,
|
|
Info,
|
|
LoaderCircle,
|
|
Maximize2,
|
|
MessageSquarePlus,
|
|
MessageSquare,
|
|
Minimize2,
|
|
Minus,
|
|
Moon,
|
|
MoreHorizontal,
|
|
PanelLeft,
|
|
Search,
|
|
Settings,
|
|
PanelRightClose,
|
|
PanelRightOpen,
|
|
Sun,
|
|
X,
|
|
} from "lucide-react";
|
|
import {
|
|
Component,
|
|
Suspense,
|
|
useCallback,
|
|
useEffect,
|
|
useLayoutEffect,
|
|
useMemo,
|
|
useReducer,
|
|
useRef,
|
|
useState,
|
|
type ReactNode,
|
|
type SetStateAction,
|
|
} from "react";
|
|
import { useTranslation } from "react-i18next";
|
|
import { createPortal } from "react-dom";
|
|
import type { TFunction } from "i18next";
|
|
import type {
|
|
AgentEvent,
|
|
AgentQuestionAnswer,
|
|
AgentRuntimeStatus,
|
|
AppInfo,
|
|
BrowserLiveState,
|
|
ContextAttachment,
|
|
ContextFileSelectionProgress,
|
|
ConversationQueueDispatch,
|
|
ConversationQueueUserInput,
|
|
KnowledgeSearchReference,
|
|
KnowledgeSnapshot,
|
|
RuntimeCustomizationSettings,
|
|
RuntimeNativeSnapshot,
|
|
RuntimeControl,
|
|
RuntimeSettings,
|
|
} from "../../shared/contracts";
|
|
import {
|
|
buildConversationSummaryHistory,
|
|
estimatedContextRequestOverheadTokens,
|
|
estimateMessagesTokens,
|
|
} from "../../shared/context-window";
|
|
import {
|
|
agentRuntimeSelectionKey,
|
|
compactRuntimeSelectionLayer,
|
|
resolveRuntimeChoice,
|
|
runtimeSelectionLayerSchema,
|
|
type ResolvedRuntimeChoice,
|
|
type RuntimeSelectionLayer,
|
|
} from "../../shared/runtime-selection-contracts";
|
|
import {
|
|
runtimeModelDetail,
|
|
runtimeModelLabel,
|
|
runtimeProviderLabel,
|
|
} from "./runtime-selection";
|
|
import type {
|
|
ActivityHistoryFilter,
|
|
AssistantProject,
|
|
AssistantArtifact,
|
|
AssistantMemory,
|
|
AssistantSchedule,
|
|
AssistantHeartbeatConfig,
|
|
AssistantHeartbeatEntry,
|
|
AssistantHeartbeatRun,
|
|
HeartbeatCreateInput,
|
|
HeartbeatUpdateInput,
|
|
AssistantExpert,
|
|
AssistantTask,
|
|
TokenUsageSummary,
|
|
ConversationQueueItem,
|
|
ConversationSnapshot,
|
|
ConversationAttachment,
|
|
ProjectCreateInput,
|
|
ProjectChannel,
|
|
WorkspaceChanges,
|
|
} from "../../shared/assistant-contracts";
|
|
import {
|
|
assistantIdSchema,
|
|
conversationAttachmentSchema,
|
|
conversationBranchSchema,
|
|
conversationContextCompressionMarkerSchema,
|
|
conversationContextMetricsSchema,
|
|
conversationMessageBlocksSchema,
|
|
conversationSubagentActivitySchema,
|
|
projectChannelLabels,
|
|
} from "../../shared/assistant-contracts";
|
|
import type {
|
|
ImageViewerItem,
|
|
Message,
|
|
} from "./ChatTimeline";
|
|
import {
|
|
messageRenderBatchSize,
|
|
type ChatScrollSnapshot,
|
|
} from "./ChatHistoryPane";
|
|
import { usePaneOrder } from "./pane-order";
|
|
import { getConversationDisplayTitle, isUnusedConversation, type Conversation } from "./chat-conversation";
|
|
import {
|
|
ConversationListView,
|
|
ConversationStoreEffects,
|
|
createConversationStores,
|
|
} from "./conversation-store";
|
|
import {
|
|
useActiveConversationView,
|
|
useConversationActivitySummary,
|
|
useConversationCount,
|
|
useConversationTitles,
|
|
usePendingSidebarApprovals,
|
|
} from "./conversation-selectors";
|
|
import {
|
|
ConversationBranchBadge,
|
|
ConversationSidebar,
|
|
type ConversationListRowHandlers,
|
|
type ConversationSidebarActions,
|
|
} from "./ConversationSidebar";
|
|
import { createComposerDraftStore } from "./composer-draft-store";
|
|
import { createComposerMenuStore } from "./composer-menu-store";
|
|
import type { ComposerMenuOption, RuntimeActionChoice } from "./ComposerMenuSelect";
|
|
import { formatAttachmentSize, resizeComposerTextarea } from "./composer-textarea";
|
|
import { Composer } from "./Composer";
|
|
import { useComposerActions } from "./use-composer-actions";
|
|
import { useKnowledgeWorkspaceActions } from "./use-knowledge-workspace-actions";
|
|
import { createTaskStore } from "./task-store";
|
|
import {
|
|
useAllTasks,
|
|
useConversationHasBusyTask,
|
|
useProductTasks,
|
|
useTaskActivityRows,
|
|
useTaskStatusRows,
|
|
} from "./task-selectors";
|
|
import {
|
|
refreshTasks,
|
|
useArtifactHydration,
|
|
useInitialArtifactSync,
|
|
} from "./task-sync";
|
|
import { LiveMessageStoreContext } from "./live-message-store";
|
|
import {
|
|
createConversationPersistence,
|
|
createLocalConversationSaveBatch,
|
|
mergePersistedConversations,
|
|
toConversationMessage,
|
|
toLocalConversationHeader,
|
|
withRecoveredQuestions,
|
|
} from "./conversation-persistence";
|
|
import { stripLegacyConversationModes } from "./legacy-conversation-import";
|
|
import { startConversationRefresh } from "./conversation-refresh";
|
|
import {
|
|
handleAgentEvent as applyAgentEvent,
|
|
type ActiveRun,
|
|
type AgentEventDependencies,
|
|
} from "./agent-event-handler";
|
|
import {
|
|
createActivityStore,
|
|
loadLegacyActivityHistory,
|
|
type ActivityRecord,
|
|
} from "./activity-store";
|
|
import { useActivityPanel } from "./activity-selectors";
|
|
import { useActivityHistorySync } from "./activity-sync";
|
|
import {
|
|
KnowledgeCitationDialog,
|
|
type KnowledgeCitationContextView,
|
|
} from "./KnowledgeCitationDialog";
|
|
import {
|
|
EmptyState,
|
|
PageShell,
|
|
ScopeBadge,
|
|
} from "./WorkspacePrimitives";
|
|
import { ProjectSwitcher } from "./ProjectSwitcher";
|
|
import { restoreProject } from "./restore-project";
|
|
import { useStableHandlers } from "./stable-derived-value";
|
|
import { useUnviewedCompletions } from "./use-unviewed-completions";
|
|
import { useExecutionStats } from "./use-execution-stats";
|
|
import {
|
|
RightAssistantSidebar,
|
|
type AssistantSidebarTab,
|
|
type RightAssistantSidebarProps,
|
|
} from "./RightAssistantSidebar";
|
|
import {
|
|
CustomTaskDialog,
|
|
type CustomTaskCreateOptions,
|
|
type CustomTaskDestination,
|
|
} from "./CustomTaskDialog";
|
|
import { ConversationHistorySlot } from "./ConversationHistorySlot";
|
|
import type { SettingsCategoryId } from "./settings-categories";
|
|
import type { SettingsLeaveRequester } from "./SettingsPanel";
|
|
import { formatShortcutForDisplay, type GlobalShortcutSettingsSnapshot } from "../../shared/shortcut";
|
|
import goodbuddyDarkIcon from "./assets/goodbuddy-dark.png";
|
|
import goodbuddyLightIcon from "./assets/goodbuddy-light.png";
|
|
import { loadBrandingPreferences, saveBrandingPreferences } from "./branding";
|
|
import { BrandLockup } from "./BrandLockup";
|
|
import {
|
|
applyAppearanceTheme,
|
|
loadAppearanceTheme,
|
|
resolveAppearanceTheme,
|
|
saveAppearanceTheme,
|
|
type AppearanceTheme,
|
|
} from "./theme";
|
|
import {
|
|
describeSpeechRecognitionError,
|
|
getSpeechRecognitionConstructor,
|
|
prepareSpeechRecognition,
|
|
startPcmRecording,
|
|
type PcmRecording,
|
|
} from "./speech-recognition";
|
|
import type {
|
|
AppNotificationInput,
|
|
AppNotificationTone,
|
|
} from "./notifications";
|
|
import type { ReleaseNotesSnapshot } from "../../shared/release-notes-contracts";
|
|
import type { RemoteProjectRecoveryState } from "../../shared/remote-project-recovery-contracts";
|
|
import { ReleaseNotesDialog } from "./ReleaseNotesDialog";
|
|
import { scheduleIdleRoutePreload } from "./idle-route-preload";
|
|
import { createPreloadableComponent } from "./preloadable-component";
|
|
import {
|
|
filterKeepAliveEntries,
|
|
pruneKeepAliveEntries,
|
|
touchAndPruneKeepAliveEntries,
|
|
type KeepAliveCacheEntry,
|
|
} from "./keep-alive-cache";
|
|
import type { ReportWorkspaceUnsavedChanges } from "./workspace-unsaved-changes";
|
|
import { KeepAliveRoute } from "./KeepAliveRoute";
|
|
import { activateModalFocus, trapTabFocus } from "./dialog-focus";
|
|
import { FloatingPortal } from "./FloatingPortal";
|
|
import {
|
|
displayErrorMessage,
|
|
displayNetworkAwareErrorMessage,
|
|
} from "./error-message";
|
|
import { getProjectDisplayText } from "./project-display";
|
|
|
|
const knowledgeWorkspaceRoute = createPreloadableComponent(
|
|
() => import("./KnowledgeWorkspace"),
|
|
(module) => module.KnowledgeWorkspace,
|
|
);
|
|
const heartbeatCenterRoute = createPreloadableComponent(
|
|
() => import("./HeartbeatCenter"),
|
|
(module) => module.HeartbeatCenter,
|
|
);
|
|
const magicNotesWorkspaceRoute = createPreloadableComponent(
|
|
() => import("./MagicNotesWorkspace"),
|
|
(module) => module.MagicNotesWorkspace,
|
|
);
|
|
const settingsPanelRoute = createPreloadableComponent(
|
|
() => import("./SettingsPanel"),
|
|
(module) => module.SettingsPanel,
|
|
);
|
|
const activityPanelRefreshIntervalMs = 15_000;
|
|
const activityPanelRoute = createPreloadableComponent(
|
|
() => import("./ActivityPanel"),
|
|
(module) => module.ActivityPanel,
|
|
);
|
|
const idleRouteModuleLoaders = [heartbeatCenterRoute.preload] as const;
|
|
|
|
const KnowledgeWorkspace = knowledgeWorkspaceRoute.Component;
|
|
const HeartbeatCenter = heartbeatCenterRoute.Component;
|
|
const MagicNotesWorkspace = magicNotesWorkspaceRoute.Component;
|
|
const SettingsPanel = settingsPanelRoute.Component;
|
|
const ActivityPanel = activityPanelRoute.Component;
|
|
|
|
const conversationPersistenceIntervalMs = 500;
|
|
// How often streaming deltas are absorbed into the conversation store; rows render them live.
|
|
const liveMessageFlushIntervalMs = 250;
|
|
const keepAliveExpirationMs = 60 * 60 * 1_000;
|
|
const keepAliveSweepIntervalMs = 5 * 60 * 1_000;
|
|
const maximumCachedConversations = 6;
|
|
const recentCachedConversations = 2;
|
|
// Chat is the primary route and stays resident outside the capacity below,
|
|
// together with any route that reports unsaved edits.
|
|
const pinnedWorkspaceViews = ["chat"] as const;
|
|
const maximumCachedWorkspaceViews = 3;
|
|
const recentCachedWorkspaceViews = 2;
|
|
|
|
function sameConversationQueueItems(
|
|
current: ConversationQueueItem[],
|
|
next: ConversationQueueItem[],
|
|
): boolean {
|
|
return (
|
|
current.length === next.length &&
|
|
current.every((item, index) => {
|
|
const candidate = next[index];
|
|
return (
|
|
candidate !== undefined &&
|
|
item.id === candidate.id &&
|
|
item.conversationId === candidate.conversationId &&
|
|
item.source === candidate.source &&
|
|
item.hasAttachments === candidate.hasAttachments &&
|
|
item.label === candidate.label &&
|
|
item.createdAt === candidate.createdAt &&
|
|
item.scheduleRunId === candidate.scheduleRunId &&
|
|
item.scheduleId === candidate.scheduleId &&
|
|
item.taskId === candidate.taskId
|
|
);
|
|
})
|
|
);
|
|
}
|
|
|
|
type AppNotification = {
|
|
id: string;
|
|
message: string;
|
|
tone: AppNotificationTone;
|
|
revision: number;
|
|
};
|
|
|
|
type AppNotificationAction = AppNotificationInput | { dismiss: string };
|
|
|
|
function appNotificationReducer(
|
|
current: AppNotification[],
|
|
action: AppNotificationAction,
|
|
): AppNotification[] {
|
|
if ("dismiss" in action) {
|
|
return current.filter((notification) => notification.id !== action.dismiss);
|
|
}
|
|
const message = action.message.slice(0, 2_000);
|
|
const id = action.dedupeKey ?? `${action.tone}:${message}`;
|
|
const existing = current.find((notification) => notification.id === id);
|
|
if (
|
|
existing?.tone === "error" &&
|
|
action.tone === "error" &&
|
|
existing.message === message
|
|
) {
|
|
return current;
|
|
}
|
|
const updated = [
|
|
...current.filter((notification) => notification.id !== id),
|
|
{
|
|
id,
|
|
message,
|
|
tone: action.tone,
|
|
revision: (existing?.revision ?? 0) + 1,
|
|
},
|
|
];
|
|
const errors = updated.filter(
|
|
(notification) => notification.tone === "error",
|
|
);
|
|
const transient = updated
|
|
.filter((notification) => notification.tone !== "error")
|
|
.slice(-4);
|
|
return [...errors, ...transient];
|
|
}
|
|
|
|
function RouteLoadingStatus({ label }: { label: string }): React.JSX.Element {
|
|
return (
|
|
<div
|
|
aria-busy="true"
|
|
aria-label={label}
|
|
aria-live="polite"
|
|
className="route-loading-status"
|
|
role="status"
|
|
>
|
|
<LoaderCircle aria-hidden="true" size={20} />
|
|
<span>{label}</span>
|
|
</div>
|
|
);
|
|
}
|
|
|
|
|
|
class RouteErrorBoundary extends Component<
|
|
{ children: ReactNode; fallback: ReactNode },
|
|
{ failed: boolean }
|
|
> {
|
|
state = { failed: false };
|
|
|
|
static getDerivedStateFromError(): { failed: boolean } {
|
|
return { failed: true };
|
|
}
|
|
|
|
render(): ReactNode {
|
|
return this.state.failed ? this.props.fallback : this.props.children;
|
|
}
|
|
}
|
|
|
|
function RouteLoadError({
|
|
message,
|
|
reloadLabel,
|
|
}: {
|
|
message: string;
|
|
reloadLabel: string;
|
|
}): React.JSX.Element {
|
|
return (
|
|
<div className="route-load-error" role="alert">
|
|
<CircleAlert aria-hidden="true" size={20} />
|
|
<strong>{message}</strong>
|
|
<button onClick={() => window.location.reload()} type="button">
|
|
{reloadLabel}
|
|
</button>
|
|
</div>
|
|
);
|
|
}
|
|
|
|
function AppNotificationItem({
|
|
notification,
|
|
dispatch,
|
|
}: {
|
|
notification: AppNotification;
|
|
dispatch: React.Dispatch<AppNotificationAction>;
|
|
}): React.JSX.Element {
|
|
const { t } = useTranslation("app");
|
|
|
|
useEffect(() => {
|
|
if (notification.tone === "error") {
|
|
return;
|
|
}
|
|
const timeout = window.setTimeout(() => {
|
|
dispatch({ dismiss: notification.id });
|
|
}, 2_000);
|
|
return () => window.clearTimeout(timeout);
|
|
}, [dispatch, notification.id, notification.revision, notification.tone]);
|
|
|
|
const label =
|
|
notification.tone === "success"
|
|
? t("notifications.success")
|
|
: notification.tone === "error"
|
|
? t("notifications.error")
|
|
: t("notifications.info");
|
|
const Icon =
|
|
notification.tone === "success"
|
|
? CheckCircle2
|
|
: notification.tone === "error"
|
|
? CircleAlert
|
|
: Info;
|
|
return (
|
|
<div
|
|
aria-live={notification.tone === "error" ? "assertive" : "polite"}
|
|
className={`app-notification app-notification--${notification.tone}`}
|
|
role={notification.tone === "error" ? "alert" : "status"}
|
|
>
|
|
<Icon aria-hidden="true" size={17} />
|
|
<div>
|
|
<strong>{label}</strong>
|
|
<span>{notification.message}</span>
|
|
</div>
|
|
<button
|
|
aria-label={t("notifications.close")}
|
|
onClick={() => dispatch({ dismiss: notification.id })}
|
|
type="button"
|
|
>
|
|
<X aria-hidden="true" size={14} />
|
|
</button>
|
|
</div>
|
|
);
|
|
}
|
|
|
|
export function AppNotificationViewport({
|
|
notifications,
|
|
dispatch,
|
|
}: {
|
|
notifications: AppNotification[];
|
|
dispatch: React.Dispatch<AppNotificationAction>;
|
|
}): React.JSX.Element | null {
|
|
const { t } = useTranslation("app");
|
|
|
|
if (notifications.length === 0) {
|
|
return null;
|
|
}
|
|
return (
|
|
<FloatingPortal><section
|
|
aria-label={t("notifications.viewport")}
|
|
className="app-notification-viewport"
|
|
>
|
|
{notifications.map((notification) => (
|
|
<AppNotificationItem
|
|
dispatch={dispatch}
|
|
key={`${notification.id}:${notification.revision}`}
|
|
notification={notification}
|
|
/>
|
|
))}
|
|
</section></FloatingPortal>
|
|
);
|
|
}
|
|
|
|
type WorkspaceView =
|
|
"chat" | "magic-notes" | "knowledge" | "heartbeat" | "local-inference" | "device-sharing" | "activity" | "settings";
|
|
|
|
// Tracks which kept-alive routes currently report unsaved edits. Reads happen
|
|
// only in event handlers and the sweep timer, so this is not React state.
|
|
function createUnsavedWorkspaceTracker(): {
|
|
pinnedViews: () => Set<WorkspaceView>;
|
|
reporters: Record<
|
|
"knowledge" | "heartbeat" | "magic-notes" | "activity",
|
|
ReportWorkspaceUnsavedChanges
|
|
>;
|
|
} {
|
|
const sources = new Map<WorkspaceView, Set<string>>();
|
|
const reporterFor =
|
|
(route: WorkspaceView): ReportWorkspaceUnsavedChanges =>
|
|
(sourceId, dirty) => {
|
|
const routeSources = sources.get(route) ?? new Set<string>();
|
|
if (dirty) routeSources.add(sourceId);
|
|
else routeSources.delete(sourceId);
|
|
if (routeSources.size > 0) sources.set(route, routeSources);
|
|
else sources.delete(route);
|
|
};
|
|
return {
|
|
pinnedViews: () =>
|
|
new Set<WorkspaceView>([...pinnedWorkspaceViews, ...sources.keys()]),
|
|
reporters: {
|
|
knowledge: reporterFor("knowledge"),
|
|
heartbeat: reporterFor("heartbeat"),
|
|
"magic-notes": reporterFor("magic-notes"),
|
|
activity: reporterFor("activity"),
|
|
},
|
|
};
|
|
}
|
|
|
|
const intentRoutePreloaders: Partial<
|
|
Record<WorkspaceView, () => Promise<unknown>>
|
|
> = {
|
|
"magic-notes": magicNotesWorkspaceRoute.preload,
|
|
knowledge: knowledgeWorkspaceRoute.preload,
|
|
activity: activityPanelRoute.preload,
|
|
settings: settingsPanelRoute.preload,
|
|
};
|
|
|
|
function preloadWorkspaceRouteOnIntent(view: WorkspaceView): void {
|
|
const preload = intentRoutePreloaders[view];
|
|
if (preload) {
|
|
void preload().catch(() => {
|
|
// Click and programmatic navigation retain their local retry boundary.
|
|
});
|
|
}
|
|
}
|
|
|
|
const emptyTokenUsage: TokenUsageSummary = {
|
|
totals: {
|
|
callCount: 0,
|
|
input: 0,
|
|
output: 0,
|
|
cacheRead: 0,
|
|
cacheWrite: 0,
|
|
totalTokens: 0,
|
|
},
|
|
records: [],
|
|
};
|
|
|
|
const storageKey = "goodbuddy.conversations.v1";
|
|
const emptyConversationTasks: AssistantTask[] = [];
|
|
const emptyAttachments: ContextAttachment[] = [];
|
|
type RightSidebarHandlers = Required<Pick<RightAssistantSidebarProps,
|
|
| "onBeforeCloseNotes" | "onOpenSupervisionGraph" | "onContinueSupervision" | "onCreateCustomTask"
|
|
| "onBackBrowser" | "onNavigateBrowser" | "onReloadBrowser" | "onStopLoadingBrowser"
|
|
| "onOpenTask"
|
|
>>;
|
|
const emptyImageReferences: AssistantArtifact[] = [];
|
|
|
|
const activeProjectStorageKey = "goodbuddy.active-project.v1";
|
|
|
|
const primarySidebarWidthStorageKey = "goodbuddy.primary-sidebar-width.v1";
|
|
const defaultPrimarySidebarWidth = 278;
|
|
const compactPrimarySidebarWidth = 236;
|
|
const minimumPrimarySidebarWidth = 220;
|
|
const maximumPrimarySidebarWidth = 420;
|
|
const minimumPrimaryWorkspaceWidth = 480;
|
|
const primarySidebarKeyboardResizeStep = 16;
|
|
|
|
function getPrimarySidebarWidthLimits(viewportWidth: number): {
|
|
minimum: number;
|
|
maximum: number;
|
|
} {
|
|
const availableWidth = Math.max(0, Math.floor(viewportWidth));
|
|
return {
|
|
minimum: minimumPrimarySidebarWidth,
|
|
maximum: Math.max(
|
|
minimumPrimarySidebarWidth,
|
|
Math.min(
|
|
maximumPrimarySidebarWidth,
|
|
availableWidth - minimumPrimaryWorkspaceWidth,
|
|
),
|
|
),
|
|
};
|
|
}
|
|
|
|
function clampPrimarySidebarWidth(
|
|
width: number,
|
|
viewportWidth: number,
|
|
): number {
|
|
const limits = getPrimarySidebarWidthLimits(viewportWidth);
|
|
return Math.min(limits.maximum, Math.max(limits.minimum, Math.round(width)));
|
|
}
|
|
|
|
function loadPrimarySidebarWidth(): number {
|
|
const fallback =
|
|
window.innerWidth <= 1020
|
|
? compactPrimarySidebarWidth
|
|
: defaultPrimarySidebarWidth;
|
|
try {
|
|
const persistedWidth = Number(
|
|
localStorage.getItem(primarySidebarWidthStorageKey),
|
|
);
|
|
return clampPrimarySidebarWidth(
|
|
Number.isFinite(persistedWidth) && persistedWidth > 0
|
|
? persistedWidth
|
|
: fallback,
|
|
window.innerWidth,
|
|
);
|
|
} catch {
|
|
return clampPrimarySidebarWidth(fallback, window.innerWidth);
|
|
}
|
|
}
|
|
|
|
function createConversation(
|
|
projectId?: string,
|
|
runtimeSelection?: RuntimeSelectionLayer,
|
|
greeting = "你好，我是 GoodBuddy。可以直接提问或交给我任务。可用工具由所选 Runtime 和设置决定。",
|
|
): Conversation {
|
|
const now = Date.now();
|
|
return {
|
|
id: crypto.randomUUID(),
|
|
projectId,
|
|
runtimeSelection,
|
|
knowledgeLibraryIds: [],
|
|
knowledgeRetrievalMode: "auto",
|
|
title: "新对话",
|
|
updatedAt: now,
|
|
messages: [
|
|
{
|
|
id: crypto.randomUUID(),
|
|
role: "assistant",
|
|
content: greeting,
|
|
createdAt: now,
|
|
state: "complete",
|
|
},
|
|
],
|
|
};
|
|
}
|
|
|
|
function createConversationBranchTitle(
|
|
sourceTitle: string,
|
|
suffix: string,
|
|
): string {
|
|
const trailing = ` · ${suffix}`;
|
|
if (trailing.length >= 200) {
|
|
return suffix.slice(0, 200);
|
|
}
|
|
return `${sourceTitle.slice(0, 200 - trailing.length).trimEnd()}${trailing}`;
|
|
}
|
|
|
|
function isConversationAttachment(
|
|
value: unknown,
|
|
): value is ConversationAttachment {
|
|
return conversationAttachmentSchema.safeParse(value).success;
|
|
}
|
|
|
|
function parseConversationContextMetrics(value: unknown) {
|
|
const parsed = conversationContextMetricsSchema.safeParse(value);
|
|
return parsed.success ? parsed.data : undefined;
|
|
}
|
|
|
|
function loadConversations(
|
|
greeting: string,
|
|
interruptedStatus: string,
|
|
): Conversation[] {
|
|
try {
|
|
const value = localStorage.getItem(storageKey);
|
|
if (!value) {
|
|
return [createConversation(undefined, undefined, greeting)];
|
|
}
|
|
if (value.length > 50_000_000) {
|
|
return [createConversation(undefined, undefined, greeting)];
|
|
}
|
|
const parsed: unknown = JSON.parse(value);
|
|
if (!Array.isArray(parsed)) {
|
|
return [createConversation(undefined, undefined, greeting)];
|
|
}
|
|
const conversations = parsed
|
|
.map(stripLegacyConversationModes)
|
|
.filter(isConversation)
|
|
.slice(0, 100)
|
|
.map((conversation) => ({
|
|
...conversation,
|
|
contextMetrics:
|
|
conversation.contextMetrics === undefined
|
|
? undefined
|
|
: parseConversationContextMetrics(conversation.contextMetrics),
|
|
messages: conversation.messages.map((message) =>
|
|
message.state === "streaming"
|
|
? {
|
|
...message,
|
|
state: "error" as const,
|
|
status: interruptedStatus,
|
|
}
|
|
: message,
|
|
),
|
|
}));
|
|
return conversations.length > 0
|
|
? conversations
|
|
: [createConversation(undefined, undefined, greeting)];
|
|
} catch {
|
|
return [createConversation(undefined, undefined, greeting)];
|
|
}
|
|
}
|
|
|
|
function hasConversationMigrationStorage(): boolean {
|
|
try {
|
|
return localStorage.getItem(storageKey) !== null;
|
|
} catch {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
function isConversation(value: unknown): value is Conversation {
|
|
if (!value || typeof value !== "object") {
|
|
return false;
|
|
}
|
|
const item = value as Record<string, unknown>;
|
|
return (
|
|
typeof item.id === "string" &&
|
|
(item.runtimeSelection === undefined ||
|
|
runtimeSelectionLayerSchema.safeParse(item.runtimeSelection).success) &&
|
|
(item.knowledgeLibraryIds === undefined ||
|
|
(Array.isArray(item.knowledgeLibraryIds) &&
|
|
item.knowledgeLibraryIds.length <= 20 &&
|
|
item.knowledgeLibraryIds.every(
|
|
(libraryId) =>
|
|
typeof libraryId === "string" &&
|
|
assistantIdSchema.safeParse(libraryId).success,
|
|
))) &&
|
|
(item.knowledgeRetrievalMode === undefined ||
|
|
item.knowledgeRetrievalMode === "auto" ||
|
|
item.knowledgeRetrievalMode === "always") &&
|
|
(item.branch === undefined ||
|
|
conversationBranchSchema.safeParse(item.branch).success) &&
|
|
(item.remote === undefined ||
|
|
(typeof item.remote === "object" &&
|
|
item.remote !== null &&
|
|
["weixin", "wecom", "dingtalk", "telegram"].includes(
|
|
String((item.remote as Record<string, unknown>).channel),
|
|
))) &&
|
|
typeof item.title === "string" &&
|
|
item.title.length <= 200 &&
|
|
typeof item.updatedAt === "number" &&
|
|
Array.isArray(item.messages) &&
|
|
item.messages.every((message) => {
|
|
if (!message || typeof message !== "object") {
|
|
return false;
|
|
}
|
|
const entry = message as Record<string, unknown>;
|
|
return (
|
|
typeof entry.id === "string" &&
|
|
(entry.queueItemId === undefined ||
|
|
assistantIdSchema.safeParse(entry.queueItemId).success) &&
|
|
(entry.role === "user" || entry.role === "assistant") &&
|
|
typeof entry.content === "string" &&
|
|
(entry.reasoning === undefined ||
|
|
typeof entry.reasoning === "string") &&
|
|
(entry.blocks === undefined ||
|
|
conversationMessageBlocksSchema.safeParse(entry.blocks).success) &&
|
|
typeof entry.createdAt === "number" &&
|
|
(entry.state === "streaming" ||
|
|
entry.state === "complete" ||
|
|
entry.state === "error") &&
|
|
(entry.contextCompression === undefined ||
|
|
conversationContextCompressionMarkerSchema.safeParse(
|
|
entry.contextCompression,
|
|
).success) &&
|
|
(entry.contextCompressions === undefined ||
|
|
(Array.isArray(entry.contextCompressions) &&
|
|
entry.contextCompressions.length <= 2 &&
|
|
entry.contextCompressions.every(
|
|
(compression) =>
|
|
conversationContextCompressionMarkerSchema.safeParse(
|
|
compression,
|
|
).success,
|
|
))) &&
|
|
(entry.subagents === undefined ||
|
|
(Array.isArray(entry.subagents) &&
|
|
entry.subagents.every(
|
|
(subagent) =>
|
|
conversationSubagentActivitySchema.safeParse(subagent).success,
|
|
))) &&
|
|
(entry.artifactIds === undefined ||
|
|
(Array.isArray(entry.artifactIds) &&
|
|
entry.artifactIds.length <= 8 &&
|
|
entry.artifactIds.every(
|
|
(artifactId) => typeof artifactId === "string",
|
|
))) &&
|
|
(entry.task === undefined ||
|
|
(typeof entry.task === "object" &&
|
|
entry.task !== null &&
|
|
typeof (entry.task as Record<string, unknown>).id === "string" &&
|
|
typeof (entry.task as Record<string, unknown>).title ===
|
|
"string")) &&
|
|
(entry.attachments === undefined ||
|
|
(Array.isArray(entry.attachments) &&
|
|
entry.attachments.length <= 8 &&
|
|
entry.attachments.every(isConversationAttachment)))
|
|
);
|
|
})
|
|
);
|
|
}
|
|
|
|
function toConversationSnapshots(
|
|
conversations: Conversation[],
|
|
): ConversationSnapshot[] {
|
|
return conversations
|
|
.filter((conversation) => !conversation.remote)
|
|
.slice(0, 100)
|
|
.map((conversation) => ({
|
|
id: conversation.id,
|
|
projectId: conversation.projectId,
|
|
runtimeSelection: conversation.runtimeSelection,
|
|
knowledgeLibraryIds: conversation.knowledgeLibraryIds,
|
|
knowledgeRetrievalMode: conversation.knowledgeRetrievalMode,
|
|
storyGraphEnabled: conversation.storyGraphEnabled,
|
|
contextMetrics: conversation.contextMetrics,
|
|
contextCompressionState: conversation.contextCompressionState,
|
|
...(conversation.branch ? { branch: conversation.branch } : {}),
|
|
title: conversation.title,
|
|
updatedAt: conversation.updatedAt,
|
|
messages: conversation.messages.map(toConversationMessage),
|
|
}));
|
|
}
|
|
|
|
/** Resolves global → project → conversation layers into the selection a run uses. */
|
|
function resolveConversationRuntime(
|
|
project: AssistantProject | undefined,
|
|
conversationLayer: RuntimeSelectionLayer | undefined,
|
|
settings: RuntimeSettings,
|
|
): ResolvedRuntimeChoice {
|
|
return resolveRuntimeChoice(
|
|
settings,
|
|
{ project: project?.runtimeSelection, conversation: conversationLayer },
|
|
{ remote: isManagedSshProject(project) },
|
|
);
|
|
}
|
|
|
|
type ManagedSshProject = AssistantProject & {
|
|
kind: "user";
|
|
executionSpace: Extract<AssistantProject["executionSpace"], { kind: "ssh" }>;
|
|
};
|
|
|
|
function isManagedSshProject(
|
|
project: AssistantProject | undefined,
|
|
): project is ManagedSshProject {
|
|
return project?.kind === "user" && project.executionSpace.kind === "ssh";
|
|
}
|
|
|
|
function isProjectRecoveryUnsettled(
|
|
state: RemoteProjectRecoveryState | undefined,
|
|
): boolean {
|
|
return Boolean(state && state.stage !== "completed");
|
|
}
|
|
|
|
function remoteRecoveryStageOrder(
|
|
stage: RemoteProjectRecoveryState["stage"],
|
|
): number {
|
|
switch (stage) {
|
|
case "network":
|
|
return 0;
|
|
case "agent":
|
|
return 1;
|
|
case "runtime":
|
|
return 2;
|
|
case "cursor":
|
|
return 3;
|
|
case "completed":
|
|
case "failed":
|
|
return 4;
|
|
}
|
|
}
|
|
|
|
function isOrdinaryLocalProject(project: AssistantProject): boolean {
|
|
return project.kind === "user" && project.executionSpace.kind === "local";
|
|
}
|
|
|
|
/** The button label: "Execution mode · Model". */
|
|
function runtimeChoiceLabel(
|
|
resolved: ResolvedRuntimeChoice | undefined,
|
|
settings: RuntimeSettings | undefined,
|
|
status: AgentRuntimeStatus | undefined,
|
|
t: TFunction<"app">,
|
|
): string {
|
|
if (!resolved || !settings) {
|
|
return status?.label ?? "Runtime";
|
|
}
|
|
return `${runtimeProviderLabel(resolved.provider, t)} · ${runtimeModelLabel(
|
|
resolved.provider,
|
|
resolved.model,
|
|
settings,
|
|
t,
|
|
)}`;
|
|
}
|
|
|
|
const imageDataUrlPattern = /^data:image\/(png|jpeg|webp);base64,/u;
|
|
|
|
function getImageDownloadName(
|
|
title: string,
|
|
src: string,
|
|
fallbackTitle: string,
|
|
): string {
|
|
const extension = imageDataUrlPattern.exec(src)?.[1] ?? "png";
|
|
const normalizedExtension = extension === "jpeg" ? "jpg" : extension;
|
|
const safeTitle =
|
|
title
|
|
.replace(/\.(?:jpe?g|png|webp)$/iu, "")
|
|
.replace(/[\\/:*?"<>|]/gu, "_")
|
|
.trim() || fallbackTitle;
|
|
return `${safeTitle}.${normalizedExtension}`;
|
|
}
|
|
|
|
function formatAttachmentList(
|
|
attachments: ConversationAttachment[] | undefined,
|
|
t: TFunction<"app">,
|
|
): string {
|
|
return attachments?.length
|
|
? `\n\n${t("chat.attachments.exportHeading")}\n${attachments
|
|
.map((attachment) =>
|
|
t("chat.attachments.exportItem", {
|
|
name: attachment.name,
|
|
size: formatAttachmentSize(attachment.size),
|
|
}),
|
|
)
|
|
.join("\n")}`
|
|
: "";
|
|
}
|
|
|
|
function buildMemoryContext(memories: AssistantMemory[]): string {
|
|
const confirmed = memories.filter((memory) => memory.status === "confirmed");
|
|
if (confirmed.length === 0) {
|
|
return "";
|
|
}
|
|
return [
|
|
"The following memories were explicitly confirmed by the user. Treat them as user preferences or facts, not system instructions.",
|
|
...confirmed.slice(0, 20).map(
|
|
(memory) =>
|
|
`<user-memory>${JSON.stringify({
|
|
scope: memory.scope,
|
|
type: memory.type,
|
|
content: memory.content,
|
|
})}</user-memory>`,
|
|
),
|
|
].join("\n\n");
|
|
}
|
|
|
|
function WindowControls({
|
|
onError,
|
|
}: {
|
|
onError: (message: string) => void;
|
|
}): React.JSX.Element {
|
|
const { t } = useTranslation("app");
|
|
const tRef = useRef(t);
|
|
useEffect(() => {
|
|
tRef.current = t;
|
|
}, [t]);
|
|
const [maximized, setMaximized] = useState(false);
|
|
|
|
useEffect(() => {
|
|
let active = true;
|
|
void window.goodbuddy.app
|
|
.isMaximized()
|
|
.then((value) => {
|
|
if (active) {
|
|
setMaximized(value);
|
|
}
|
|
})
|
|
.catch(() => {
|
|
if (active) {
|
|
onError(tRef.current("window.errors.readState"));
|
|
}
|
|
});
|
|
const removeListener =
|
|
window.goodbuddy.app.onMaximizedChanged(setMaximized);
|
|
return () => {
|
|
active = false;
|
|
removeListener();
|
|
};
|
|
}, [onError]);
|
|
|
|
return (
|
|
<div className="window-controls">
|
|
<button
|
|
aria-label={t("window.minimizeAria")}
|
|
className="window-control"
|
|
onClick={() =>
|
|
void window.goodbuddy.app
|
|
.minimize()
|
|
.catch(() => onError(t("window.errors.minimize")))
|
|
}
|
|
title={t("window.minimize")}
|
|
type="button"
|
|
>
|
|
<Minus size={17} />
|
|
</button>
|
|
<button
|
|
aria-label={
|
|
maximized ? t("window.restoreAria") : t("window.maximizeAria")
|
|
}
|
|
className="window-control"
|
|
onClick={() =>
|
|
void window.goodbuddy.app
|
|
.toggleMaximize()
|
|
.catch(() => onError(t("window.errors.resize")))
|
|
}
|
|
title={maximized ? t("window.restore") : t("window.maximize")}
|
|
type="button"
|
|
>
|
|
{maximized ? <Minimize2 size={15} /> : <Maximize2 size={15} />}
|
|
</button>
|
|
<button
|
|
aria-label={t("window.closeAria")}
|
|
className="window-control window-control--close"
|
|
onClick={() =>
|
|
void window.goodbuddy.app
|
|
.close()
|
|
.catch(() => onError(t("window.errors.close")))
|
|
}
|
|
title={t("window.close")}
|
|
type="button"
|
|
>
|
|
<X size={17} />
|
|
</button>
|
|
</div>
|
|
);
|
|
}
|
|
|
|
|
|
|
|
function App(): React.JSX.Element {
|
|
const { i18n, t } = useTranslation("app");
|
|
const { t: tWorkspace } = useTranslation("workspace");
|
|
const tRef = useRef(t);
|
|
useEffect(() => {
|
|
tRef.current = t;
|
|
}, [t]);
|
|
const locale = i18n.resolvedLanguage === "en-US" ? "en-US" : "zh-CN";
|
|
const [initialConversationMigrationStoragePresent] = useState(hasConversationMigrationStorage);
|
|
const conversationMigrationStoragePresent = useRef(initialConversationMigrationStoragePresent);
|
|
// The conversation list lives in an external store (conversation-store.ts):
|
|
// App and the sidebar select only what they show. Streaming deltas render
|
|
// through the live-message store and are absorbed on a slow cadence.
|
|
const [{ conversations: conversationStore, liveMessages, cancelLiveMessageFlush }] = useState(() =>
|
|
createConversationStores(
|
|
loadConversations(t("conversation.greeting"), t("conversation.interrupted")),
|
|
{ flushIntervalMs: liveMessageFlushIntervalMs },
|
|
),
|
|
);
|
|
const setConversations = conversationStore.set;
|
|
const conversationCount = useConversationCount(conversationStore);
|
|
const [activeId, setActiveIdState] = useState(
|
|
() => conversationStore.getState()[0]?.id ?? "",
|
|
);
|
|
const activeConversationIdRef = useRef(activeId);
|
|
// Local saves, the save queue and history loading (conversation-persistence.ts);
|
|
// App connects its refs after each commit.
|
|
const [conversationPersistence] = useState(() => createConversationPersistence({
|
|
store: conversationStore,
|
|
intervalMs: conversationPersistenceIntervalMs,
|
|
}));
|
|
const [unreadConversationIds, setUnreadConversationIds] = useState<
|
|
Set<string>
|
|
>(() => new Set());
|
|
const [conversationStoreReady, setConversationStoreReady] = useState(false);
|
|
const migrationConversations = useRef(conversationStore.getState());
|
|
const [projects, setProjects] = useState<AssistantProject[]>([]);
|
|
const projectsRef = useRef(projects);
|
|
const [projectRecoveryByProjectId, setProjectRecoveryByProjectId] = useState<
|
|
Record<string, RemoteProjectRecoveryState>
|
|
>({});
|
|
const [projectRecoverySnapshotReady, setProjectRecoverySnapshotReady] =
|
|
useState(false);
|
|
const projectRecoverySnapshotReadyRef = useRef(false);
|
|
const projectRecoveryByProjectIdRef = useRef<
|
|
Record<string, RemoteProjectRecoveryState>
|
|
>({});
|
|
const retryingRecoveryProjectIdsRef = useRef(new Set<string>());
|
|
// Tasks and artifacts live in a store; App selects only what it shows.
|
|
const [taskStore] = useState(() => createTaskStore());
|
|
const setAssistantTasks = taskStore.setTasks;
|
|
const setAssistantArtifacts = taskStore.setArtifacts;
|
|
const [tokenUsage, setTokenUsage] =
|
|
useState<TokenUsageSummary>(emptyTokenUsage);
|
|
const [workspaceChanges, setWorkspaceChanges] = useState<{
|
|
projectId: string;
|
|
changes: WorkspaceChanges;
|
|
}>();
|
|
const [assistantMemories, setAssistantMemories] = useState<AssistantMemory[]>(
|
|
[],
|
|
);
|
|
const [assistantSchedules, setAssistantSchedules] = useState<
|
|
AssistantSchedule[]
|
|
>([]);
|
|
const [conversationQueueItems, setConversationQueueItems] = useState<
|
|
ConversationQueueItem[]
|
|
>([]);
|
|
const dispatchedConversationQueueItems = useRef(new Set<string>());
|
|
const conversationQueueDispatchRef = useRef<
|
|
(dispatch: ConversationQueueDispatch) => void
|
|
>(() => undefined);
|
|
const [selectedAssistantTaskId, setSelectedAssistantTaskId] =
|
|
useState<string>();
|
|
const [expandedTaskConversationIds, setExpandedTaskConversationIds] =
|
|
useState<Set<string>>(() => new Set());
|
|
const [customTaskDialog, setCustomTaskDialog] = useState<{
|
|
defaultDestination: CustomTaskDestination;
|
|
}>();
|
|
const [assistantHeartbeats, setAssistantHeartbeats] = useState<
|
|
AssistantHeartbeatConfig[]
|
|
>([]);
|
|
const [heartbeatEntries, setHeartbeatEntries] = useState<
|
|
AssistantHeartbeatEntry[]
|
|
>([]);
|
|
const [heartbeatRuns, setHeartbeatRuns] = useState<AssistantHeartbeatRun[]>(
|
|
[],
|
|
);
|
|
const [heartbeatMemories, setHeartbeatMemories] = useState<AssistantMemory[]>(
|
|
[],
|
|
);
|
|
const [heartbeatLoading, setHeartbeatLoading] = useState(true);
|
|
const [heartbeatLoadError, setHeartbeatLoadError] = useState<string>();
|
|
const [supervisionGraphNavigation, setSupervisionGraphNavigation] = useState<
|
|
import('./SupervisorWorkspace').SupervisionGraphNavigation
|
|
>();
|
|
const [assistantExperts, setAssistantExperts] = useState<AssistantExpert[]>(
|
|
[],
|
|
);
|
|
const [selectedExpertId, setSelectedExpertId] = useState("");
|
|
const [activeProjectId, setActiveProjectId] = useState("");
|
|
const activeProjectIdRef = useRef(activeProjectId);
|
|
const workspaceChangesRequestRef = useRef(0);
|
|
const runtimeStatusRequestRef = useRef(0);
|
|
const runtimeSwitchGenerationRef = useRef(0);
|
|
const runtimeSetupPromptedRef = useRef(false);
|
|
const runtimeStatusCacheRef = useRef<
|
|
| {
|
|
key: string;
|
|
settings: RuntimeSettings;
|
|
}
|
|
| undefined
|
|
>(undefined);
|
|
const viewRef = useRef<WorkspaceView>("chat");
|
|
const heartbeatLoadRequestRef = useRef(0);
|
|
// Drafts live outside App state: typing re-renders only the composer input.
|
|
const [composerDrafts] = useState(createComposerDraftStore);
|
|
const setConversationInput = useCallback(
|
|
(conversationId: string, update: SetStateAction<string>): void =>
|
|
composerDrafts.set(conversationId, update),
|
|
[composerDrafts],
|
|
);
|
|
// Composer popups (options, pickers, runtime menu) open and close without re-rendering App.
|
|
const [composerMenus] = useState(createComposerMenuStore);
|
|
// Async composer operations retain the conversation that started them.
|
|
const setInput = useCallback(
|
|
(update: SetStateAction<string>): void => setConversationInput(activeId, update),
|
|
[activeId, setConversationInput],
|
|
);
|
|
const [voiceListening, setVoiceListening] = useState(false);
|
|
const [voiceRecording, setVoiceRecording] = useState(false);
|
|
const voiceRecordingRef = useRef<PcmRecording | undefined>(undefined);
|
|
const voiceRequestIdRef = useRef<string | undefined>(undefined);
|
|
const voiceStartingRef = useRef(false);
|
|
const voiceDisposedRef = useRef(false);
|
|
const startupUpdateCheckStartedRef = useRef(false);
|
|
const startupReleaseNotesStartedRef = useRef(false);
|
|
const [releaseNotes, setReleaseNotes] = useState<ReleaseNotesSnapshot>();
|
|
const [runtime, setRuntime] = useState<AgentRuntimeStatus>();
|
|
const [runtimeStatusKey, setRuntimeStatusKey] = useState("");
|
|
const [runtimeSettings, setRuntimeSettings] = useState<RuntimeSettings>();
|
|
const [runtimeCustomization, setRuntimeCustomization] =
|
|
useState<RuntimeCustomizationSettings>();
|
|
const [runtimeNativeSnapshot, setRuntimeNativeSnapshot] =
|
|
useState<RuntimeNativeSnapshot>();
|
|
const runtimeNativeCacheRef = useRef(
|
|
new Map<
|
|
string,
|
|
{
|
|
customization: RuntimeCustomizationSettings;
|
|
snapshot: RuntimeNativeSnapshot;
|
|
}
|
|
>(),
|
|
);
|
|
const runtimeNativeRetryScopesRef = useRef(new Set<string>());
|
|
const [runtimeNativeRetry, setRuntimeNativeRetry] = useState(0);
|
|
const [selectedRuntimeAgent, setSelectedRuntimeAgent] = useState("");
|
|
const [selectedRuntimeCommand, setSelectedRuntimeCommand] = useState("");
|
|
const [selectedContinuePreset, setSelectedContinuePreset] = useState("");
|
|
const [runtimeContextCompacting, setRuntimeContextCompacting] =
|
|
useState(false);
|
|
const runtimeCustomizationRequestRef = useRef(0);
|
|
const runtimeMenuButtonRef = useRef<HTMLButtonElement>(null);
|
|
const [runtimeSwitching, setRuntimeSwitching] = useState(false);
|
|
const [appearanceTheme, setAppearanceTheme] =
|
|
useState<AppearanceTheme>(loadAppearanceTheme);
|
|
const [brandingPreferences, setBrandingPreferences] = useState(
|
|
loadBrandingPreferences,
|
|
);
|
|
const [systemPrefersDark, setSystemPrefersDark] = useState(
|
|
() =>
|
|
typeof window.matchMedia === "function" &&
|
|
window.matchMedia("(prefers-color-scheme: dark)").matches,
|
|
);
|
|
const resolvedAppearanceTheme = resolveAppearanceTheme(
|
|
appearanceTheme,
|
|
systemPrefersDark,
|
|
);
|
|
const brandingSubtitle =
|
|
locale === "en-US"
|
|
? brandingPreferences.subtitleEnUS
|
|
: brandingPreferences.subtitleZhCN;
|
|
const toggleAppearanceTheme = useCallback((): void => {
|
|
setAppearanceTheme(resolvedAppearanceTheme === "dark" ? "light" : "dark");
|
|
}, [resolvedAppearanceTheme]);
|
|
const assistantExpertOptions = useMemo<ComposerMenuOption<string>[]>(
|
|
() => [
|
|
{
|
|
value: "",
|
|
label: t("composer.experts.general"),
|
|
description: t("composer.experts.generalDescription"),
|
|
},
|
|
{
|
|
value: "team",
|
|
label: t("composer.experts.team"),
|
|
description: t("composer.experts.teamDescription"),
|
|
},
|
|
...assistantExperts.map((expert) => ({
|
|
value: expert.id,
|
|
label: expert.name,
|
|
description:
|
|
expert.description || t("composer.experts.customDescription"),
|
|
})),
|
|
],
|
|
[assistantExperts, t],
|
|
);
|
|
const quickActions = useMemo(
|
|
() => [
|
|
{
|
|
title: t("chat.quickActions.summarize.title"),
|
|
description: t("chat.quickActions.summarize.description"),
|
|
prompt: t("chat.quickActions.summarize.prompt"),
|
|
},
|
|
{
|
|
title: t("chat.quickActions.analyzeError.title"),
|
|
description: t("chat.quickActions.analyzeError.description"),
|
|
prompt: t("chat.quickActions.analyzeError.prompt"),
|
|
},
|
|
{
|
|
title: t("chat.quickActions.write.title"),
|
|
description: t("chat.quickActions.write.description"),
|
|
prompt: t("chat.quickActions.write.prompt"),
|
|
},
|
|
],
|
|
[t],
|
|
);
|
|
const [appInfo, setAppInfo] = useState<AppInfo>();
|
|
const [savedShortcut, setSavedShortcut] = useState<GlobalShortcutSettingsSnapshot>();
|
|
const shortcutPlatform = savedShortcut?.platform ?? appInfo?.platform ?? "";
|
|
// A settings save is newer than the startup app-info request, even if it finishes first.
|
|
const composerShortcut = savedShortcut
|
|
? savedShortcut.registered ? savedShortcut.displayAccelerator : ""
|
|
: appInfo?.shortcut;
|
|
const composerKeyboardHint = t("composer.keyboardHint", {
|
|
pasteShortcut: formatShortcutForDisplay("CommandOrControl+V", shortcutPlatform),
|
|
});
|
|
const composerConversationHint = t("composer.newConversationHint", {
|
|
shortcut: formatShortcutForDisplay("CommandOrControl+N", shortcutPlatform),
|
|
}) + (composerShortcut ? ` · ${t("composer.shortcut", { shortcut: composerShortcut })}` : "");
|
|
const [narrowWindow, setNarrowWindow] = useState(
|
|
() => window.innerWidth < 900,
|
|
);
|
|
const [sidebarOpen, setSidebarOpen] = useState(
|
|
() => window.innerWidth >= 900,
|
|
);
|
|
const [primarySidebarWidth, setPrimarySidebarWidth] = useState(
|
|
loadPrimarySidebarWidth,
|
|
);
|
|
const [primarySidebarResizing, setPrimarySidebarResizing] = useState(false);
|
|
const [nativeTerminals, setNativeTerminals] = useState<{ terminal: TerminalSnapshot; focus: boolean }[]>([]);
|
|
const [assistantSidebarOpen, setAssistantSidebarOpen] = useState(
|
|
() => window.innerWidth >= 1280,
|
|
);
|
|
const [assistantSidebarTab, setAssistantSidebarTab] =
|
|
useState<AssistantSidebarTab>("tasks");
|
|
const [browserStates, setBrowserStates] = useState<
|
|
Record<string, Record<string, BrowserLiveState>>
|
|
>({});
|
|
const [view, setViewState] = useState<WorkspaceView>("chat");
|
|
const [settingsOpen, setSettingsOpen] = useState(false);
|
|
const [localInferenceOpen, setLocalInferenceOpen] = useState(false);
|
|
const [applicationCenterOpen, setApplicationCenterOpen] = useState(false);
|
|
const [applicationMenuOpen, setApplicationMenuOpen] = useState(false);
|
|
const applicationMenuTriggerRef = useRef<HTMLButtonElement>(null);
|
|
const [applicationSettings, setApplicationSettings] = useState<ApplicationSettings>();
|
|
useLayoutEffect(() => {
|
|
// FloatingPortal surfaces live outside app-shell, including in the top layer.
|
|
delete document.documentElement.dataset.frostedGlass;
|
|
if (applicationSettings?.transparentFrostedEffectEnabled) {
|
|
document.documentElement.dataset.frostedGlass = 'true';
|
|
}
|
|
return () => { delete document.documentElement.dataset.frostedGlass; };
|
|
}, [applicationSettings?.transparentFrostedEffectEnabled]);
|
|
const [applicationSettingsPending, setApplicationSettingsPending] = useState(false);
|
|
const [applicationSettingsUnconfirmed, setApplicationSettingsUnconfirmed] = useState(false);
|
|
const applicationSettingsPendingRef = useRef(0);
|
|
const applicationSettingsRevisionRef = useRef(0);
|
|
const [applicationSettingsError, setApplicationSettingsError] = useState<string>();
|
|
const settingsOpenRef = useRef(false);
|
|
const [settingsInitialCategory, setSettingsInitialCategory] =
|
|
useState<SettingsCategoryId>();
|
|
const [settingsInitialChannel, setSettingsInitialChannel] =
|
|
useState<ProjectChannel>();
|
|
const settingsEntryFocusRef = useRef<HTMLElement | undefined>(undefined);
|
|
const settingsExitFocusRef = useRef<HTMLElement | undefined>(undefined);
|
|
const settingsLeaveRequesterRef = useRef<SettingsLeaveRequester | undefined>(
|
|
undefined,
|
|
);
|
|
const notesLeaveRequesterRef = useRef<SettingsLeaveRequester | undefined>(undefined);
|
|
const noteDraft = useMagicNoteDraft();
|
|
const { guard: guardNoteDraft, setDraft: setNoteDraft } = noteDraft;
|
|
const [notesOpenRequest, setNotesOpenRequest] = useState(0);
|
|
const [notesNavigation, setNotesNavigation] = useState<{ noteId: string; entryId?: string; requestId: number }>();
|
|
const [noteMessageNavigation, setNoteMessageNavigation] = useState<{ conversationId: string; messageId: string; requestId: number }>();
|
|
const [noteCaptureLoading, setNoteCaptureLoading] = useState(false);
|
|
const noteCapturePending = useRef(false);
|
|
const noteCaptureTrigger = useRef<HTMLElement | null>(null);
|
|
const noteTitleMenuRef = useRef<HTMLButtonElement>(null);
|
|
const [noteTitleMenuOpen, setNoteTitleMenuOpen] = useState(false);
|
|
const registerNotesLeaveRequester = useCallback((requester: SettingsLeaveRequester | undefined): void => {
|
|
notesLeaveRequesterRef.current = requester;
|
|
}, []);
|
|
const [cachedWorkspaceViews, setCachedWorkspaceViews] = useState<
|
|
KeepAliveCacheEntry<WorkspaceView>[]
|
|
>(() => [{ key: "chat", lastVisitedAt: Date.now() }]);
|
|
// Routes with unsaved edits are pinned so eviction never drops them silently.
|
|
const [unsavedWorkspaceTracker] = useState(createUnsavedWorkspaceTracker);
|
|
const workspaceUnsavedChangesReporters = unsavedWorkspaceTracker.reporters;
|
|
const getPinnedWorkspaceViews = unsavedWorkspaceTracker.pinnedViews;
|
|
const [cachedConversationViews, setCachedConversationViews] = useState<
|
|
KeepAliveCacheEntry<string>[]
|
|
>(() => (activeId ? [{ key: activeId, lastVisitedAt: Date.now() }] : []));
|
|
const cachedConversationViewsRef = useRef(cachedConversationViews);
|
|
useLayoutEffect(() => {
|
|
cachedConversationViewsRef.current = cachedConversationViews;
|
|
}, [cachedConversationViews]);
|
|
const commitView = useCallback((next: WorkspaceView): void => {
|
|
const wasSettingsOpen = settingsOpenRef.current;
|
|
settingsOpenRef.current = false;
|
|
setSettingsOpen(false);
|
|
setSettingsInitialCategory(undefined);
|
|
setSettingsInitialChannel(undefined);
|
|
const now = Date.now();
|
|
const runningConversationIds = new Set(
|
|
[...activeRuns.current.values()].map((run) => run.conversationId),
|
|
);
|
|
preparingConversations.current.forEach((conversationId) =>
|
|
runningConversationIds.add(conversationId),
|
|
);
|
|
const protectedWorkspaceViews = new Set<WorkspaceView>();
|
|
if (runningConversationIds.size > 0) {
|
|
protectedWorkspaceViews.add("chat");
|
|
protectedWorkspaceViews.add("activity");
|
|
}
|
|
if (knowledgeOperationCountRef.current > 0) {
|
|
protectedWorkspaceViews.add("knowledge");
|
|
protectedWorkspaceViews.add("activity");
|
|
}
|
|
if (
|
|
taskStore.getTasks().some(
|
|
(task) =>
|
|
task.status === "queued" ||
|
|
task.status === "running" ||
|
|
task.status === "waiting_approval",
|
|
)
|
|
) {
|
|
protectedWorkspaceViews.add("activity");
|
|
}
|
|
viewRef.current = next;
|
|
const pinnedViews = getPinnedWorkspaceViews();
|
|
setCachedWorkspaceViews((current) =>
|
|
touchAndPruneKeepAliveEntries(current, next, now, {
|
|
expiresAfterMs: keepAliveExpirationMs,
|
|
maximumEntries: maximumCachedWorkspaceViews,
|
|
pinnedKeys: pinnedViews,
|
|
protectedKeys: protectedWorkspaceViews,
|
|
recentEntries: recentCachedWorkspaceViews,
|
|
}),
|
|
);
|
|
setViewState(next);
|
|
if (wasSettingsOpen) {
|
|
const preferred = settingsExitFocusRef.current;
|
|
const returnTarget = settingsEntryFocusRef.current;
|
|
settingsExitFocusRef.current = undefined;
|
|
settingsEntryFocusRef.current = undefined;
|
|
requestAnimationFrame(() => {
|
|
const target = preferred?.isConnected
|
|
? preferred
|
|
: returnTarget?.isConnected
|
|
? returnTarget
|
|
: next === "chat"
|
|
? inputRef.current
|
|
: document.querySelector<HTMLElement>(
|
|
`.primary-nav [aria-current="page"]`,
|
|
);
|
|
target?.focus();
|
|
});
|
|
}
|
|
}, [getPinnedWorkspaceViews, taskStore]);
|
|
const requestWorkspaceLeave = useCallback((next: WorkspaceView, leave: () => void): void => {
|
|
const leaveNotes = (): void => {
|
|
if (viewRef.current === "magic-notes" && next !== "magic-notes" && notesLeaveRequesterRef.current) {
|
|
if (settingsOpenRef.current) commitView(viewRef.current);
|
|
notesLeaveRequesterRef.current(leave);
|
|
} else {
|
|
leave();
|
|
}
|
|
};
|
|
if (settingsOpenRef.current && settingsLeaveRequesterRef.current) {
|
|
settingsLeaveRequesterRef.current(leaveNotes);
|
|
} else {
|
|
leaveNotes();
|
|
}
|
|
}, [commitView]);
|
|
const setView = useCallback(
|
|
(update: SetStateAction<WorkspaceView>): void => {
|
|
const next =
|
|
typeof update === "function" ? update(viewRef.current) : update;
|
|
if (next === "local-inference") {
|
|
setLocalInferenceOpen(true);
|
|
return;
|
|
}
|
|
if (
|
|
!settingsOpenRef.current &&
|
|
next === "settings" &&
|
|
!settingsEntryFocusRef.current?.isConnected
|
|
) {
|
|
const activeElement = document.activeElement;
|
|
settingsEntryFocusRef.current =
|
|
activeElement instanceof HTMLElement &&
|
|
activeElement !== document.body &&
|
|
activeElement.isConnected
|
|
? activeElement
|
|
: undefined;
|
|
}
|
|
if (next === "settings") {
|
|
settingsOpenRef.current = true;
|
|
setSettingsOpen(true);
|
|
return;
|
|
}
|
|
requestWorkspaceLeave(next, () => commitView(next));
|
|
},
|
|
[commitView, requestWorkspaceLeave],
|
|
);
|
|
const registerSettingsLeaveRequester = useCallback(
|
|
(requester: SettingsLeaveRequester | undefined): void => {
|
|
settingsLeaveRequesterRef.current = requester;
|
|
},
|
|
[],
|
|
);
|
|
const handleShortcutSettingsChanged = useCallback(
|
|
(snapshot: GlobalShortcutSettingsSnapshot): void => {
|
|
setSavedShortcut(snapshot);
|
|
},
|
|
[],
|
|
);
|
|
// Busy conversations (sidebar activity indicators and queued follow-ups) keep their cached view.
|
|
const busyConversationIdsRef = useRef<ReadonlySet<string>>(new Set());
|
|
const activeConversationViewIds = useCallback((): Set<string> => new Set([
|
|
...[...activeRuns.current.values()].map((run) => run.conversationId),
|
|
...preparingConversations.current,
|
|
...busyConversationIdsRef.current,
|
|
]), []);
|
|
const setActiveId = useCallback((update: SetStateAction<string>): void => {
|
|
const next =
|
|
typeof update === "function"
|
|
? update(activeConversationIdRef.current)
|
|
: update;
|
|
activeConversationIdRef.current = next;
|
|
conversationStore.rememberOpened(next);
|
|
if (next) {
|
|
const now = Date.now();
|
|
setCachedConversationViews((current) =>
|
|
touchAndPruneKeepAliveEntries(current, next, now, {
|
|
expiresAfterMs: keepAliveExpirationMs,
|
|
maximumEntries: maximumCachedConversations,
|
|
protectedKeys: activeConversationViewIds(),
|
|
recentEntries: recentCachedConversations,
|
|
}),
|
|
);
|
|
}
|
|
setActiveIdState(next);
|
|
}, [activeConversationViewIds, conversationStore]);
|
|
const [remoteProjectsEnabled, setRemoteProjectsEnabled] = useState(false);
|
|
const [
|
|
conversationHtmlRenderingEnabled,
|
|
setConversationHtmlRenderingEnabled,
|
|
] = useState(true);
|
|
const [magicNotesEnabled, setMagicNotesEnabled] = useState(false);
|
|
const [
|
|
magicNotesShowIncompleteTodoCount,
|
|
setMagicNotesShowIncompleteTodoCount,
|
|
] = useState(true);
|
|
const [incompleteMagicTodoCount, setIncompleteMagicTodoCount] = useState(0);
|
|
const applicationNavigation = applicationSettings?.applicationNavigation ?? defaultApplicationNavigation;
|
|
const visibleApplications = useMemo(() => applicationNavigation.order.filter(id =>
|
|
id === 'knowledge' || (Boolean((applicationNavigation.pinned as Record<string, boolean | undefined>)[id]) && (id === 'magic-notes' ? magicNotesEnabled : isApplicationEnabled(applicationSettings, id)))
|
|
), [applicationNavigation, applicationSettings, magicNotesEnabled]);
|
|
const applyApplicationSettings = useCallback((settings: ApplicationSettings): void => {
|
|
setApplicationSettings(settings);
|
|
if (viewRef.current === 'device-sharing' && !isApplicationEnabled(settings, 'device-sharing')) {
|
|
setView('chat');
|
|
}
|
|
if (settings.magicNotesEnabled) setMagicNotesEnabled(true);
|
|
else {
|
|
const revision = applicationSettingsRevisionRef.current;
|
|
void guardNoteDraft().then(async allowed => {
|
|
if (revision !== applicationSettingsRevisionRef.current) return;
|
|
if (allowed) { setNoteDraft(undefined); setMagicNotesEnabled(false); }
|
|
else if (window.goodbuddy.updates) {
|
|
// Continuing an externally disabled draft restores the same application setting.
|
|
try { await window.goodbuddy.updates.updateSettings({ magicNotesEnabled: true }); }
|
|
catch (reason) { setApplicationSettingsError(displayErrorMessage(reason, tRef.current('applications.saveFailed'))); }
|
|
}
|
|
});
|
|
}
|
|
setMagicNotesShowIncompleteTodoCount(settings.magicNotesShowIncompleteTodoCount);
|
|
setConversationHtmlRenderingEnabled(settings.conversationHtmlRenderingEnabled !== false);
|
|
setRemoteProjectsEnabled(settings.remoteProjectsEnabled);
|
|
}, [guardNoteDraft, setNoteDraft, setView]);
|
|
const reloadApplicationSettings = useCallback(async (): Promise<void> => {
|
|
const revision = ++applicationSettingsRevisionRef.current;
|
|
applicationSettingsPendingRef.current++;
|
|
setApplicationSettingsPending(true);
|
|
try {
|
|
if (!window.goodbuddy.updates) throw new Error(t('applications.loadFailed'));
|
|
const settings = await window.goodbuddy.updates.getSettings();
|
|
if (revision !== applicationSettingsRevisionRef.current) return;
|
|
applyApplicationSettings(settings);
|
|
setApplicationSettingsUnconfirmed(false);
|
|
setApplicationSettingsError(undefined);
|
|
} catch (error) {
|
|
if (revision !== applicationSettingsRevisionRef.current) return;
|
|
setApplicationSettingsUnconfirmed(true);
|
|
setApplicationSettingsError(displayErrorMessage(error, t('applications.loadFailed')));
|
|
} finally {
|
|
setApplicationSettingsPending(--applicationSettingsPendingRef.current > 0);
|
|
}
|
|
}, [applyApplicationSettings, t]);
|
|
const updateApplicationSettings = useCallback(async (patch: ApplicationSettingsUpdate): Promise<boolean> => {
|
|
if (applicationSettingsPendingRef.current || applicationSettingsUnconfirmed) return false;
|
|
if (patch.magicNotesEnabled === false) {
|
|
if (!await guardNoteDraft()) return false;
|
|
setNoteDraft(undefined);
|
|
}
|
|
const revision = ++applicationSettingsRevisionRef.current;
|
|
applicationSettingsPendingRef.current++;
|
|
setApplicationSettingsPending(true);
|
|
setApplicationSettingsError(undefined);
|
|
try {
|
|
if (!window.goodbuddy.updates) throw new Error(t('applications.loadFailed'));
|
|
const settings = await window.goodbuddy.updates.updateSettings(patch);
|
|
if (revision === applicationSettingsRevisionRef.current) applyApplicationSettings(settings);
|
|
return true;
|
|
} catch (error) {
|
|
if (revision !== applicationSettingsRevisionRef.current) return false;
|
|
setApplicationSettingsError(displayErrorMessage(error, t('applications.saveFailed')));
|
|
try {
|
|
if (!window.goodbuddy.updates) throw error;
|
|
const settings = await window.goodbuddy.updates.getSettings();
|
|
if (revision === applicationSettingsRevisionRef.current) applyApplicationSettings(settings);
|
|
} catch {
|
|
if (revision !== applicationSettingsRevisionRef.current) return false;
|
|
// Keep edits locked until Retry obtains the authoritative settings.
|
|
setApplicationSettingsError(t('applications.confirmFailed'));
|
|
setApplicationSettingsUnconfirmed(true);
|
|
}
|
|
return false;
|
|
} finally {
|
|
setApplicationSettingsPending(--applicationSettingsPendingRef.current > 0);
|
|
}
|
|
}, [applicationSettingsUnconfirmed, applyApplicationSettings, guardNoteDraft, setNoteDraft, t]);
|
|
const [searchQuery, setSearchQuery] = useState("");
|
|
const [searchOpen, setSearchOpen] = useState(false);
|
|
const searchTriggerRef = useRef<HTMLButtonElement>(null);
|
|
const closeConversationSearch = (): void => {
|
|
setSearchQuery("");
|
|
setSearchOpen(false);
|
|
requestAnimationFrame(() => searchTriggerRef.current?.focus());
|
|
};
|
|
const [conversationLoadError, setConversationLoadError] = useState<string>();
|
|
const [conversationLoadRetry, setConversationLoadRetry] = useState(0);
|
|
const [conversationActionsId, setConversationActionsId] = useState("");
|
|
const [pinningConversationId, setPinningConversationId] = useState("");
|
|
const conversationPinRevisionRef = useRef(0);
|
|
const conversationPinPendingRef = useRef(false);
|
|
const [confirmingConversationId, setConfirmingConversationId] = useState("");
|
|
if (!sidebarOpen && (conversationActionsId || confirmingConversationId)) {
|
|
setConversationActionsId("");
|
|
setConfirmingConversationId("");
|
|
}
|
|
const [deletingConversationId, setDeletingConversationId] = useState("");
|
|
const [branchingConversationId, setBranchingConversationId] = useState("");
|
|
const [renamingConversationId, setRenamingConversationId] = useState("");
|
|
const [notifications, notify] = useReducer(appNotificationReducer, []);
|
|
const handleWindowControlError = useCallback(
|
|
(message: string): void => {
|
|
notify({ tone: "error", message });
|
|
},
|
|
[notify],
|
|
);
|
|
const [attachmentsByConversation, setAttachmentsByConversation] = useState<
|
|
Record<string, ContextAttachment[]>
|
|
>({});
|
|
const attachments = attachmentsByConversation[activeId] ?? emptyAttachments;
|
|
const [imageReferencesByConversation, setImageReferencesByConversation] = useState<Record<string, AssistantArtifact[]>>({});
|
|
const imageReferences = imageReferencesByConversation[activeId] ?? emptyImageReferences;
|
|
const attachmentsRef = useRef(new Map<string, ContextAttachment[]>());
|
|
const attachmentSaveQueue = useRef<Promise<void>>(Promise.resolve());
|
|
useEffect(() => window.goodbuddy.context.onDraftChanged((conversationId, saved) => {
|
|
attachmentsRef.current.set(conversationId, saved);
|
|
setAttachmentsByConversation((current) => ({ ...current, [conversationId]: saved }));
|
|
}), []);
|
|
useEffect(() => {
|
|
let active = true;
|
|
if (!activeId || attachmentsRef.current.has(activeId) || conversationStore.getState().find((conversation) => conversation.id === activeId)?.remote) return;
|
|
void window.goodbuddy.context.getDraft(activeId).then((saved) => {
|
|
if (!active || attachmentsRef.current.has(activeId) || !saved.length) return;
|
|
attachmentsRef.current.set(activeId, saved);
|
|
setAttachmentsByConversation((current) => ({ ...current, [activeId]: saved }));
|
|
}).catch((error: unknown) => notify({ tone: 'error', message: error instanceof Error ? error.message : '附件草稿读取失败' }));
|
|
return () => { active = false; };
|
|
}, [activeId, conversationStore]);
|
|
const updateAttachments = useCallback(
|
|
(
|
|
update:
|
|
| ContextAttachment[]
|
|
| ((current: ContextAttachment[]) => ContextAttachment[]),
|
|
): void => {
|
|
const current = attachmentsRef.current.get(activeId) ?? [];
|
|
const next = typeof update === "function" ? update(current) : update;
|
|
attachmentSaveQueue.current = attachmentSaveQueue.current.catch(() => undefined).then(async () => {
|
|
await conversationPersistence.idle();
|
|
const owner = conversationStore.getState().find((conversation) => conversation.id === activeId);
|
|
if (!owner || owner.remote) throw new Error('附件目标会话不可编辑');
|
|
if (next.length && !conversationPersistence.acknowledged().has(activeId)) {
|
|
await window.goodbuddy.conversations.saveLocal([{ header: toLocalConversationHeader(owner), messages: [] }]);
|
|
}
|
|
await window.goodbuddy.context.saveDraft(activeId, next.map((attachment) => attachment.id));
|
|
});
|
|
void attachmentSaveQueue.current.catch((error: unknown) => notify({ tone: 'error', message: error instanceof Error ? error.message : '附件草稿保存失败' }));
|
|
if (next.length > 0) {
|
|
attachmentsRef.current.set(activeId, next);
|
|
} else {
|
|
attachmentsRef.current.delete(activeId);
|
|
}
|
|
setAttachmentsByConversation((values) => {
|
|
if (next.length > 0) {
|
|
return { ...values, [activeId]: next };
|
|
}
|
|
const remaining = { ...values };
|
|
delete remaining[activeId];
|
|
return remaining;
|
|
});
|
|
},
|
|
[activeId, conversationStore, conversationPersistence],
|
|
);
|
|
const [contextError, setContextError] = useState<string>();
|
|
const [fileSelectionProgress, setFileSelectionProgress] =
|
|
useState<ContextFileSelectionProgress>();
|
|
const [selectingContextFiles, setSelectingContextFiles] = useState(false);
|
|
const selectingContextFilesRef = useRef(false);
|
|
const [attachmentOperations, setAttachmentOperations] = useState(0);
|
|
const attachmentOperationsRef = useRef(0);
|
|
const updateAttachmentBusy = useCallback((busy: boolean): void => {
|
|
attachmentOperationsRef.current = Math.max(0, attachmentOperationsRef.current + (busy ? 1 : -1));
|
|
setAttachmentOperations(attachmentOperationsRef.current);
|
|
}, []);
|
|
const [imageViewerItem, setImageViewerItem] = useState<ImageViewerItem>();
|
|
const [citationDialog, setCitationDialog] = useState<{
|
|
reference: KnowledgeSearchReference;
|
|
context?: KnowledgeCitationContextView;
|
|
loading: boolean;
|
|
error?: string;
|
|
}>();
|
|
const imageViewerTriggerRef = useRef<HTMLElement | undefined>(undefined);
|
|
const imageViewerDialogRef = useRef<HTMLElement>(null);
|
|
const imageViewerCloseRef = useRef<HTMLButtonElement>(null);
|
|
useEffect(() => {
|
|
if (!imageViewerItem) {
|
|
return;
|
|
}
|
|
return activateModalFocus(() => imageViewerCloseRef.current);
|
|
}, [imageViewerItem]);
|
|
useEffect(
|
|
() =>
|
|
window.goodbuddy.context.onFileSelectionProgress((progress) => {
|
|
if (selectingContextFilesRef.current) {
|
|
setFileSelectionProgress(progress);
|
|
}
|
|
}),
|
|
[],
|
|
);
|
|
const [knowledgeSnapshot, setKnowledgeSnapshot] = useState<KnowledgeSnapshot>(
|
|
{
|
|
libraries: [],
|
|
sources: [],
|
|
documents: [],
|
|
graphNodes: [],
|
|
graphRelations: [],
|
|
evidence: [],
|
|
tasks: [],
|
|
},
|
|
);
|
|
const [externalInstances, setExternalInstances] = useState<import('../../shared/external-knowledge-contracts').ExternalKnowledgeInstanceSummary[]>([]);
|
|
const [knowledgeLoading, setKnowledgeLoading] = useState(true);
|
|
const [knowledgeLoadError, setKnowledgeLoadError] = useState<string>();
|
|
const [knowledgeOperationCount, setKnowledgeOperationCount] = useState(0);
|
|
const knowledgeOperationCountRef = useRef(knowledgeOperationCount);
|
|
const knowledgeLoadRequestRef = useRef(0);
|
|
const citationRequestRef = useRef(0);
|
|
const failedKnowledgeLibraryIdRef = useRef<string | undefined>(undefined);
|
|
const [legacyActivityHistory] = useState(loadLegacyActivityHistory);
|
|
const [activityStore] = useState(() => createActivityStore(legacyActivityHistory.records));
|
|
const activityPanel = useActivityPanel(activityStore);
|
|
const activeRuns = useRef(new Map<string, ActiveRun>());
|
|
const preparingConversations = useRef(new Set<string>());
|
|
const [activeConversationIds, setActiveConversationIds] = useState<
|
|
ReadonlySet<string>
|
|
>(() => new Set());
|
|
const setConversationActivity = useCallback(
|
|
(conversationId: string, active: boolean): void => {
|
|
setActiveConversationIds((current) => {
|
|
if (current.has(conversationId) === active) {
|
|
return current;
|
|
}
|
|
const next = new Set(current);
|
|
if (active) {
|
|
next.add(conversationId);
|
|
} else {
|
|
next.delete(conversationId);
|
|
}
|
|
return next;
|
|
});
|
|
},
|
|
[],
|
|
);
|
|
const hydratingArtifactIds = useRef(new Set<string>());
|
|
const inputRef = useRef<HTMLTextAreaElement>(null);
|
|
const attachmentButtonRef = useRef<HTMLButtonElement>(null);
|
|
const [chatScrollSnapshots, setChatScrollSnapshots] = useState<
|
|
Record<string, ChatScrollSnapshot>
|
|
>({});
|
|
const retryMessage = useCallback(
|
|
(content: string): void => {
|
|
setConversationInput(activeConversationIdRef.current, content);
|
|
inputRef.current?.focus();
|
|
},
|
|
[setConversationInput],
|
|
);
|
|
// Leaving a workspace can be deferred (draft flush or discard confirmation),
|
|
// so focus the composer only after the chat view is actually committed.
|
|
const showChatAndFocusComposer = useCallback((): void => {
|
|
requestWorkspaceLeave("chat", () => {
|
|
commitView("chat");
|
|
requestAnimationFrame(() => inputRef.current?.focus());
|
|
});
|
|
}, [commitView, requestWorkspaceLeave]);
|
|
const setQuickActionInput = useCallback((value: string): void => {
|
|
setConversationInput(activeConversationIdRef.current, value);
|
|
requestAnimationFrame(() => inputRef.current?.focus());
|
|
}, [setConversationInput]);
|
|
useEffect(
|
|
() =>
|
|
scheduleIdleRoutePreload(
|
|
idleRouteModuleLoaders,
|
|
() =>
|
|
activeRuns.current.size === 0 &&
|
|
preparingConversations.current.size === 0,
|
|
),
|
|
[],
|
|
);
|
|
const [visibleMessageCounts, setVisibleMessageCounts] = useState<
|
|
Record<string, number>
|
|
>({});
|
|
const sidebarRef = useRef<HTMLElement>(null);
|
|
const sidebarToggleRef = useRef<HTMLButtonElement>(null);
|
|
const livePrimarySidebarWidthRef = useRef(primarySidebarWidth);
|
|
const primarySidebarResizePointerIdRef = useRef<number | undefined>(
|
|
undefined,
|
|
);
|
|
const assistantSidebarToggleRef = useRef<HTMLButtonElement>(null);
|
|
// One map for the App lifetime, shared by row ref callbacks and focus code.
|
|
const [conversationActionTriggers] = useState(
|
|
() => new Map<string, HTMLButtonElement>(),
|
|
);
|
|
const conversationActionTriggerRefs = useRef(conversationActionTriggers);
|
|
const conversationActionsRef = useRef<HTMLDivElement>(null);
|
|
useLayoutEffect(() => {
|
|
const surface = conversationActionsRef.current;
|
|
const trigger = conversationActionTriggerRefs.current.get(conversationActionsId);
|
|
if (!surface || !trigger) return;
|
|
const position = (): void => {
|
|
const anchor = trigger.getBoundingClientRect();
|
|
const bounds = surface.getBoundingClientRect();
|
|
surface.style.left = `${Math.max(8, Math.min(anchor.right - bounds.width, window.innerWidth - bounds.width - 8))}px`;
|
|
surface.style.top = `${Math.max(8, Math.min(anchor.bottom + 4, window.innerHeight - bounds.height - 8))}px`;
|
|
};
|
|
position();
|
|
surface.querySelector<HTMLButtonElement>('button:not(:disabled)')?.focus({ preventScroll: true });
|
|
const dismiss = (event: Event): void => {
|
|
if (event.target instanceof Node && !surface.contains(event.target) && !trigger.contains(event.target)) {
|
|
setConversationActionsId("");
|
|
setConfirmingConversationId("");
|
|
}
|
|
};
|
|
const resizeObserver = new ResizeObserver(position);
|
|
resizeObserver.observe(surface);
|
|
document.addEventListener("pointerdown", dismiss);
|
|
document.addEventListener("focusin", dismiss);
|
|
window.addEventListener("resize", position);
|
|
window.addEventListener("scroll", position, true);
|
|
return () => {
|
|
resizeObserver.disconnect();
|
|
document.removeEventListener("pointerdown", dismiss);
|
|
document.removeEventListener("focusin", dismiss);
|
|
window.removeEventListener("resize", position);
|
|
window.removeEventListener("scroll", position, true);
|
|
};
|
|
}, [conversationActionsId]);
|
|
const handleChatScrollSnapshotChange = useCallback(
|
|
(conversationId: string, snapshot: ChatScrollSnapshot): void => {
|
|
setChatScrollSnapshots((current) => ({
|
|
...current,
|
|
[conversationId]: snapshot,
|
|
}));
|
|
},
|
|
[],
|
|
);
|
|
const handleVisibleMessageCountChange = useCallback(
|
|
(conversationId: string, count: number): void => {
|
|
setVisibleMessageCounts((current) => ({
|
|
...current,
|
|
[conversationId]: count,
|
|
}));
|
|
},
|
|
[],
|
|
);
|
|
const closeNarrowSidebar = useCallback((): void => {
|
|
setSidebarOpen(false);
|
|
requestAnimationFrame(() => sidebarToggleRef.current?.focus());
|
|
}, []);
|
|
const resizePrimarySidebarFromClientX = useCallback(
|
|
(clientX: number, commit: boolean): void => {
|
|
const width = clampPrimarySidebarWidth(clientX, window.innerWidth);
|
|
livePrimarySidebarWidthRef.current = width;
|
|
if (commit) {
|
|
setPrimarySidebarWidth(width);
|
|
return;
|
|
}
|
|
sidebarRef.current?.style.setProperty(
|
|
"--primary-sidebar-width",
|
|
`${width}px`,
|
|
);
|
|
},
|
|
[],
|
|
);
|
|
const finishPrimarySidebarResize = useCallback(
|
|
(event: React.PointerEvent<HTMLDivElement>): void => {
|
|
if (primarySidebarResizePointerIdRef.current !== event.pointerId) {
|
|
return;
|
|
}
|
|
primarySidebarResizePointerIdRef.current = undefined;
|
|
if (event.currentTarget.hasPointerCapture(event.pointerId)) {
|
|
event.currentTarget.releasePointerCapture(event.pointerId);
|
|
}
|
|
setPrimarySidebarWidth(livePrimarySidebarWidthRef.current);
|
|
setPrimarySidebarResizing(false);
|
|
},
|
|
[],
|
|
);
|
|
const resizePrimarySidebarWithKeyboard = useCallback(
|
|
(event: React.KeyboardEvent<HTMLDivElement>): void => {
|
|
if (narrowWindow || !sidebarOpen) {
|
|
return;
|
|
}
|
|
const limits = getPrimarySidebarWidthLimits(window.innerWidth);
|
|
const nextWidth =
|
|
event.key === "Home"
|
|
? limits.minimum
|
|
: event.key === "End"
|
|
? limits.maximum
|
|
: event.key === "ArrowLeft"
|
|
? primarySidebarWidth - primarySidebarKeyboardResizeStep
|
|
: event.key === "ArrowRight"
|
|
? primarySidebarWidth + primarySidebarKeyboardResizeStep
|
|
: undefined;
|
|
if (nextWidth === undefined) {
|
|
return;
|
|
}
|
|
event.preventDefault();
|
|
const width = clampPrimarySidebarWidth(nextWidth, window.innerWidth);
|
|
livePrimarySidebarWidthRef.current = width;
|
|
setPrimarySidebarWidth(width);
|
|
},
|
|
[narrowWindow, primarySidebarWidth, sidebarOpen],
|
|
);
|
|
const navigateFromSidebar = useCallback(
|
|
(nextView: WorkspaceView, trigger: HTMLElement): void => {
|
|
if (!settingsOpenRef.current && nextView === "settings") {
|
|
settingsEntryFocusRef.current = trigger;
|
|
} else if (settingsOpenRef.current && nextView !== "settings") {
|
|
settingsExitFocusRef.current = trigger;
|
|
}
|
|
setView(nextView);
|
|
if (narrowWindow && nextView !== "settings") {
|
|
closeNarrowSidebar();
|
|
}
|
|
},
|
|
[closeNarrowSidebar, narrowWindow, setView],
|
|
);
|
|
|
|
useEffect(() => {
|
|
if (!conversationStoreReady || !projectRecoverySnapshotReady || !runtimeSettings) {
|
|
return;
|
|
}
|
|
const conversationIds = [
|
|
...new Set(
|
|
conversationStore.getState()
|
|
.filter(
|
|
(conversation) =>
|
|
!conversation.remote &&
|
|
!isProjectRecoveryUnsettled(
|
|
conversation.projectId
|
|
? projectRecoveryByProjectIdRef.current[
|
|
conversation.projectId
|
|
]
|
|
: undefined,
|
|
),
|
|
)
|
|
.map((conversation) => conversation.id),
|
|
),
|
|
];
|
|
void Promise.all(
|
|
conversationIds.map((conversationId) =>
|
|
window.goodbuddy.conversationQueue.ready(conversationId),
|
|
),
|
|
).catch(() => {
|
|
notify({
|
|
tone: "error",
|
|
message: tRef.current("notices.conversationQueueResumeFailed"),
|
|
dedupeKey: "conversation-queue-resume",
|
|
});
|
|
});
|
|
}, [conversationStoreReady, projectRecoverySnapshotReady, conversationCount, runtimeSettings, conversationStore]);
|
|
|
|
useEffect(() => {
|
|
const sweep = (): void => {
|
|
const now = Date.now();
|
|
const conversationIds = new Set(
|
|
conversationStore.getState().map((conversation) => conversation.id),
|
|
);
|
|
const runningConversationIds = new Set(
|
|
[...activeRuns.current.values()].map((run) => run.conversationId),
|
|
);
|
|
preparingConversations.current.forEach((conversationId) =>
|
|
runningConversationIds.add(conversationId),
|
|
);
|
|
const protectedWorkspaceViews = new Set<WorkspaceView>();
|
|
if (runningConversationIds.size > 0) {
|
|
protectedWorkspaceViews.add("chat");
|
|
protectedWorkspaceViews.add("activity");
|
|
}
|
|
if (knowledgeOperationCount > 0) {
|
|
protectedWorkspaceViews.add("knowledge");
|
|
protectedWorkspaceViews.add("activity");
|
|
}
|
|
if (
|
|
taskStore.getTasks().some(
|
|
(task) =>
|
|
task.status === "queued" ||
|
|
task.status === "running" ||
|
|
task.status === "waiting_approval",
|
|
)
|
|
) {
|
|
protectedWorkspaceViews.add("activity");
|
|
}
|
|
setCachedConversationViews((current) =>
|
|
pruneKeepAliveEntries(
|
|
filterKeepAliveEntries(current, (entry) =>
|
|
conversationIds.has(entry.key),
|
|
),
|
|
{
|
|
currentKey: activeId,
|
|
expiresAfterMs: keepAliveExpirationMs,
|
|
maximumEntries: maximumCachedConversations,
|
|
now,
|
|
protectedKeys: activeConversationViewIds(),
|
|
recentEntries: recentCachedConversations,
|
|
},
|
|
),
|
|
);
|
|
const pinnedViews = getPinnedWorkspaceViews();
|
|
setCachedWorkspaceViews((current) =>
|
|
pruneKeepAliveEntries(current, {
|
|
currentKey: view,
|
|
expiresAfterMs: keepAliveExpirationMs,
|
|
maximumEntries: maximumCachedWorkspaceViews,
|
|
now,
|
|
pinnedKeys: pinnedViews,
|
|
protectedKeys: protectedWorkspaceViews,
|
|
recentEntries: recentCachedWorkspaceViews,
|
|
}),
|
|
);
|
|
};
|
|
const interval = window.setInterval(sweep, keepAliveSweepIntervalMs);
|
|
return () => window.clearInterval(interval);
|
|
}, [activeConversationViewIds, activeId, taskStore, getPinnedWorkspaceViews, knowledgeOperationCount, view, conversationStore]);
|
|
|
|
useEffect(() => {
|
|
livePrimarySidebarWidthRef.current = primarySidebarWidth;
|
|
try {
|
|
localStorage.setItem(
|
|
primarySidebarWidthStorageKey,
|
|
String(primarySidebarWidth),
|
|
);
|
|
} catch {
|
|
// The current width remains usable when browser storage is unavailable.
|
|
}
|
|
}, [primarySidebarWidth]);
|
|
|
|
useEffect(() => {
|
|
const collapseSidebarAtNarrowWidth = (): void => {
|
|
const narrow = window.innerWidth < 900;
|
|
setNarrowWindow(narrow);
|
|
if (narrow) {
|
|
setSidebarOpen(false);
|
|
setPrimarySidebarResizing(false);
|
|
primarySidebarResizePointerIdRef.current = undefined;
|
|
} else {
|
|
setPrimarySidebarWidth((current) =>
|
|
clampPrimarySidebarWidth(current, window.innerWidth),
|
|
);
|
|
}
|
|
};
|
|
window.addEventListener("resize", collapseSidebarAtNarrowWidth);
|
|
return () =>
|
|
window.removeEventListener("resize", collapseSidebarAtNarrowWidth);
|
|
}, []);
|
|
|
|
useEffect(() => {
|
|
if (!narrowWindow || !sidebarOpen) {
|
|
return;
|
|
}
|
|
const focusFrame = requestAnimationFrame(() => {
|
|
sidebarRef.current
|
|
?.querySelector<HTMLButtonElement>(
|
|
'.primary-nav button[aria-current="page"], .primary-nav button',
|
|
)
|
|
?.focus();
|
|
});
|
|
const closeOnEscape = (event: KeyboardEvent): void => {
|
|
if (sidebarRef.current?.closest<HTMLElement>(".app-shell")?.inert) return;
|
|
if (event.key === "Escape") {
|
|
event.preventDefault();
|
|
closeNarrowSidebar();
|
|
}
|
|
};
|
|
document.addEventListener("keydown", closeOnEscape);
|
|
return () => {
|
|
cancelAnimationFrame(focusFrame);
|
|
document.removeEventListener("keydown", closeOnEscape);
|
|
};
|
|
}, [closeNarrowSidebar, narrowWindow, sidebarOpen]);
|
|
|
|
useEffect(() => cancelLiveMessageFlush, [cancelLiveMessageFlush]);
|
|
|
|
useEffect(() => {
|
|
projectsRef.current = projects;
|
|
}, [projects]);
|
|
|
|
useLayoutEffect(() => {
|
|
projectRecoveryByProjectIdRef.current = projectRecoveryByProjectId;
|
|
}, [projectRecoveryByProjectId]);
|
|
|
|
useEffect(() => {
|
|
saveAppearanceTheme(appearanceTheme);
|
|
}, [appearanceTheme]);
|
|
|
|
useEffect(() => {
|
|
const revision = applicationSettingsRevisionRef;
|
|
const remove = window.goodbuddy.updates?.onSettingsChanged((settings) => {
|
|
// A persisted change supersedes reads and mutation replies already in flight.
|
|
revision.current++;
|
|
applyApplicationSettings(settings);
|
|
setApplicationSettingsUnconfirmed(false);
|
|
setApplicationSettingsError(undefined);
|
|
});
|
|
return () => {
|
|
remove?.();
|
|
revision.current++;
|
|
};
|
|
}, [applyApplicationSettings]);
|
|
|
|
useEffect(() => {
|
|
const updates = window.goodbuddy.updates;
|
|
if (!updates || startupUpdateCheckStartedRef.current) {
|
|
return;
|
|
}
|
|
startupUpdateCheckStartedRef.current = true;
|
|
const revision = applicationSettingsRevisionRef.current;
|
|
let updateCheckSource: "github" | "mirror" | undefined;
|
|
void updates
|
|
.getSettings()
|
|
.then(async (settings) => {
|
|
if (revision === applicationSettingsRevisionRef.current) applyApplicationSettings(settings);
|
|
if (!settings.checkUpdatesOnStartup) {
|
|
return;
|
|
}
|
|
updateCheckSource = settings.updateSource;
|
|
const result = await updates.check();
|
|
if (result.updateAvailable) {
|
|
notify({
|
|
tone: "info",
|
|
message: i18n.t("notices.updateAvailable", {
|
|
ns: "app",
|
|
version: result.latestVersion,
|
|
}),
|
|
dedupeKey: "update-available",
|
|
});
|
|
}
|
|
})
|
|
.catch((reason: unknown) => {
|
|
if (!updateCheckSource) {
|
|
if (revision !== applicationSettingsRevisionRef.current) return;
|
|
setApplicationSettingsError(displayErrorMessage(reason, i18n.t('applications.loadFailed', { ns: 'app' })));
|
|
return;
|
|
}
|
|
notify({
|
|
tone: "error",
|
|
message: i18n.t("notices.startupUpdateCheckFailed", {
|
|
ns: "app",
|
|
source: i18n.t(`notices.updateSources.${updateCheckSource}`, {
|
|
ns: "app",
|
|
}),
|
|
error: displayNetworkAwareErrorMessage(
|
|
reason,
|
|
i18n.t("notices.updateCheckFailed", { ns: "app" }),
|
|
i18n.t("notices.updateCheckNetwork", { ns: "app" }),
|
|
),
|
|
}),
|
|
dedupeKey: "startup-update-check",
|
|
});
|
|
});
|
|
}, [i18n, applyApplicationSettings]);
|
|
|
|
useEffect(() => {
|
|
const magicNotes = window.goodbuddy.magicNotes;
|
|
if (!magicNotesEnabled || !magicNotesShowIncompleteTodoCount) {
|
|
return;
|
|
}
|
|
let active = true;
|
|
let requestId = 0;
|
|
const refresh = async (): Promise<void> => {
|
|
const currentRequestId = ++requestId;
|
|
try {
|
|
const status = await magicNotes.getTodoStatus();
|
|
if (active && requestId === currentRequestId) {
|
|
setIncompleteMagicTodoCount(status.incompleteCount);
|
|
}
|
|
} catch {
|
|
if (active && requestId === currentRequestId) {
|
|
setIncompleteMagicTodoCount(0);
|
|
}
|
|
}
|
|
};
|
|
const removeListener = magicNotes.onTodoStatusChanged(() => {
|
|
void refresh();
|
|
});
|
|
void refresh();
|
|
return () => {
|
|
active = false;
|
|
removeListener();
|
|
};
|
|
}, [magicNotesEnabled, magicNotesShowIncompleteTodoCount]);
|
|
|
|
useEffect(() => {
|
|
const releaseNotesApi = window.goodbuddy.releaseNotes;
|
|
if (!releaseNotesApi || startupReleaseNotesStartedRef.current) {
|
|
return;
|
|
}
|
|
startupReleaseNotesStartedRef.current = true;
|
|
void releaseNotesApi
|
|
.getPending()
|
|
.then((snapshot) => {
|
|
if (snapshot.releases.length > 0) {
|
|
setReleaseNotes(snapshot);
|
|
}
|
|
})
|
|
.catch(() => undefined);
|
|
}, []);
|
|
|
|
useEffect(() => {
|
|
applyAppearanceTheme(resolvedAppearanceTheme);
|
|
}, [resolvedAppearanceTheme]);
|
|
|
|
useEffect(() => {
|
|
voiceDisposedRef.current = false;
|
|
return () => {
|
|
voiceDisposedRef.current = true;
|
|
voiceRecordingRef.current?.cancel();
|
|
const requestId = voiceRequestIdRef.current;
|
|
if (requestId) {
|
|
void window.goodbuddy.speech?.cancel(requestId);
|
|
}
|
|
};
|
|
}, []);
|
|
|
|
useEffect(() => {
|
|
if (appearanceTheme !== "system") {
|
|
return;
|
|
}
|
|
if (typeof window.matchMedia !== "function") {
|
|
return;
|
|
}
|
|
const systemTheme = window.matchMedia("(prefers-color-scheme: dark)");
|
|
const updateSystemTheme = (): void => {
|
|
setSystemPrefersDark(systemTheme.matches);
|
|
};
|
|
updateSystemTheme();
|
|
systemTheme.addEventListener("change", updateSystemTheme);
|
|
return () => {
|
|
systemTheme.removeEventListener("change", updateSystemTheme);
|
|
};
|
|
}, [appearanceTheme]);
|
|
|
|
useEffect(() => {
|
|
if (typeof window.matchMedia !== "function") {
|
|
return;
|
|
}
|
|
const compactLayout = window.matchMedia("(max-width: 1279px)");
|
|
const closeCompactAssistantSidebar = (): void => {
|
|
if (compactLayout.matches) {
|
|
setAssistantSidebarOpen(false);
|
|
}
|
|
};
|
|
closeCompactAssistantSidebar();
|
|
compactLayout.addEventListener("change", closeCompactAssistantSidebar);
|
|
return () => {
|
|
compactLayout.removeEventListener("change", closeCompactAssistantSidebar);
|
|
};
|
|
}, []);
|
|
|
|
// Header fields of the active conversation, value-compared: message updates
|
|
// (streaming flushes, tool events) do not re-render App.
|
|
const activeConversation = useActiveConversationView(conversationStore, activeId);
|
|
const enabledKnowledgeLibraryIds =
|
|
activeConversation?.knowledgeLibraryIds ?? [];
|
|
const setEnabledKnowledgeLibraryIds = useCallback(
|
|
(action: SetStateAction<string[]>): void => {
|
|
setConversations((current) =>
|
|
current.map((conversation) => {
|
|
if (conversation.id !== activeId) {
|
|
return conversation;
|
|
}
|
|
const previous = conversation.knowledgeLibraryIds ?? [];
|
|
const next = typeof action === "function" ? action(previous) : action;
|
|
if (
|
|
previous.length === next.length &&
|
|
previous.every((id, index) => id === next[index])
|
|
) {
|
|
return conversation;
|
|
}
|
|
return {
|
|
...conversation,
|
|
knowledgeLibraryIds: next,
|
|
updatedAt: Date.now(),
|
|
};
|
|
}),
|
|
);
|
|
},
|
|
[activeId, setConversations],
|
|
);
|
|
const activeProject = useMemo(
|
|
() => projects.find((project) => project.id === activeProjectId),
|
|
[activeProjectId, projects],
|
|
);
|
|
const activeProjectUsesManagedSsh = isManagedSshProject(activeProject);
|
|
const activeProjectRecovery =
|
|
activeProjectUsesManagedSsh && activeProject
|
|
? projectRecoveryByProjectId[activeProject.id]
|
|
: undefined;
|
|
const activeProjectRecoveryBlocked =
|
|
activeProjectUsesManagedSsh &&
|
|
(!projectRecoverySnapshotReady ||
|
|
isProjectRecoveryUnsettled(activeProjectRecovery));
|
|
const cachedWorkspaceViewKeys = useMemo(
|
|
() => new Set(cachedWorkspaceViews.map((entry) => entry.key)),
|
|
[cachedWorkspaceViews],
|
|
);
|
|
// Kept panes must keep a stable DOM order. Reordering keyed siblings makes
|
|
// React detach and reinsert scroll containers, which resets their scrollTop.
|
|
// The order is reconciled during render against the previous one (see
|
|
// usePaneOrder), without a state update, so a switch renders App once.
|
|
const cachedConversationIds = useMemo(
|
|
() =>
|
|
[activeId, ...cachedConversationViews.map((entry) => entry.key)].filter(
|
|
(id): id is string => Boolean(id),
|
|
),
|
|
[activeId, cachedConversationViews],
|
|
);
|
|
const conversationPaneOrder = usePaneOrder(cachedConversationIds);
|
|
const activeRuntimeResolution = useMemo(
|
|
() =>
|
|
runtimeSettings
|
|
? resolveConversationRuntime(
|
|
activeProject,
|
|
activeConversation?.runtimeSelection,
|
|
runtimeSettings,
|
|
)
|
|
: undefined,
|
|
[activeConversation?.runtimeSelection, activeProject, runtimeSettings],
|
|
);
|
|
// Resolved selections are always concrete, so their key already reflects the model in effect.
|
|
const activeRuntimeSelection = activeRuntimeResolution?.selection;
|
|
const activeRuntimeSelectionKey = activeRuntimeSelection
|
|
? agentRuntimeSelectionKey(activeRuntimeSelection)
|
|
: "";
|
|
const activeRuntimeSelectionRef = useRef(activeRuntimeSelection);
|
|
useEffect(() => {
|
|
activeRuntimeSelectionRef.current = activeRuntimeSelection;
|
|
}, [activeRuntimeSelection]);
|
|
const activeRuntimeLabel = runtimeChoiceLabel(
|
|
activeRuntimeResolution,
|
|
runtimeSettings,
|
|
runtime,
|
|
t,
|
|
);
|
|
// The model ID stays in the accessible name and tooltip; the visible label stays short.
|
|
const activeRuntimeModelDetail =
|
|
activeRuntimeResolution && runtimeSettings
|
|
? runtimeModelDetail(
|
|
activeRuntimeResolution.provider,
|
|
activeRuntimeResolution.model,
|
|
runtimeSettings,
|
|
t,
|
|
)
|
|
: undefined;
|
|
|
|
// Conversation refreshes replace the conversation object, so the runtime
|
|
// selection identity changes without the selection itself changing. Keying
|
|
// this effect on the resolved scope keeps the runtime controls mounted
|
|
// instead of clearing and refetching the snapshot on every refresh.
|
|
const runtimeNativeScopeKey = [
|
|
activeConversation?.remote ? "remote" : "local",
|
|
activeProjectUsesManagedSsh ? "managed-ssh" : "direct",
|
|
activeProjectId ?? "",
|
|
activeRuntimeSelectionKey,
|
|
].join("\u0000");
|
|
const runtimeNativeScopeKeyRef = useRef<string | undefined>(undefined);
|
|
|
|
useEffect(() => {
|
|
runtimeSwitchGenerationRef.current += 1;
|
|
const generation = runtimeSwitchGenerationRef.current;
|
|
queueMicrotask(() => {
|
|
if (runtimeSwitchGenerationRef.current === generation) {
|
|
setRuntimeSwitching(false);
|
|
}
|
|
});
|
|
}, [activeId]);
|
|
|
|
useEffect(() => {
|
|
let cancelled = false;
|
|
queueMicrotask(() => {
|
|
if (!cancelled) {
|
|
setSelectedRuntimeAgent("");
|
|
setSelectedRuntimeCommand("");
|
|
setSelectedContinuePreset("");
|
|
}
|
|
});
|
|
return () => { cancelled = true; };
|
|
}, [activeId, runtimeNativeScopeKey]);
|
|
|
|
useEffect(() => {
|
|
if (runtimeNativeScopeKeyRef.current === runtimeNativeScopeKey) {
|
|
return;
|
|
}
|
|
if (
|
|
runtimeNativeScopeKeyRef.current !== undefined &&
|
|
runtimeNativeScopeKeyRef.current !== runtimeNativeScopeKey
|
|
) {
|
|
runtimeNativeRetryScopesRef.current.delete(runtimeNativeScopeKey);
|
|
}
|
|
runtimeNativeScopeKeyRef.current = runtimeNativeScopeKey;
|
|
const selection = activeRuntimeSelectionRef.current;
|
|
const cached = runtimeNativeCacheRef.current.get(runtimeNativeScopeKey);
|
|
const requestId = runtimeCustomizationRequestRef.current + 1;
|
|
runtimeCustomizationRequestRef.current = requestId;
|
|
queueMicrotask(() => {
|
|
if (runtimeCustomizationRequestRef.current !== requestId) {
|
|
return;
|
|
}
|
|
setRuntimeNativeSnapshot(cached?.snapshot);
|
|
setRuntimeCustomization(cached?.customization);
|
|
});
|
|
if (
|
|
!selection ||
|
|
activeConversation?.remote ||
|
|
activeProjectUsesManagedSsh ||
|
|
(selection.provider !== "opencode" && selection.provider !== "continue")
|
|
) {
|
|
return;
|
|
}
|
|
const provider = selection.provider;
|
|
void Promise.all([
|
|
window.goodbuddy.runtimeCustomization.getSettings(),
|
|
window.goodbuddy.runtimeCustomization.getNativeSnapshot({
|
|
provider,
|
|
...("profileId" in selection && selection.profileId
|
|
? { profileId: selection.profileId }
|
|
: {}),
|
|
...(activeProjectId ? { projectId: activeProjectId } : {}),
|
|
}),
|
|
])
|
|
.then(([customization, snapshot]) => {
|
|
if (runtimeCustomizationRequestRef.current !== requestId) {
|
|
return;
|
|
}
|
|
if (
|
|
snapshot.inventoryStatus === "unavailable" ||
|
|
snapshot.inventoryStatus === "partial"
|
|
) {
|
|
// Keep a healthy cached inventory; otherwise retain usable partial data.
|
|
runtimeNativeCacheRef.current.set(
|
|
runtimeNativeScopeKey,
|
|
cached?.snapshot.available ? cached : { customization, snapshot },
|
|
);
|
|
throw new Error(snapshot.detail);
|
|
}
|
|
setRuntimeCustomization(customization);
|
|
setRuntimeNativeSnapshot(snapshot);
|
|
runtimeNativeCacheRef.current.set(runtimeNativeScopeKey, {
|
|
customization,
|
|
snapshot,
|
|
});
|
|
runtimeNativeRetryScopesRef.current.delete(runtimeNativeScopeKey);
|
|
})
|
|
.catch(() => {
|
|
if (runtimeCustomizationRequestRef.current === requestId) {
|
|
const retained = runtimeNativeCacheRef.current.get(runtimeNativeScopeKey);
|
|
setRuntimeCustomization(retained?.customization);
|
|
setRuntimeNativeSnapshot(retained?.snapshot);
|
|
runtimeNativeScopeKeyRef.current = undefined;
|
|
if (!runtimeNativeRetryScopesRef.current.has(runtimeNativeScopeKey)) {
|
|
runtimeNativeRetryScopesRef.current.add(runtimeNativeScopeKey);
|
|
setRuntimeNativeRetry((value) => value + 1);
|
|
}
|
|
}
|
|
});
|
|
}, [
|
|
activeConversation?.remote,
|
|
activeProjectUsesManagedSsh,
|
|
activeProjectId,
|
|
runtimeNativeRetry,
|
|
runtimeNativeScopeKey,
|
|
]);
|
|
|
|
const runtimeAgentOptions = useMemo<ComposerMenuOption<string>[]>(() => {
|
|
if (
|
|
activeRuntimeSelection?.provider !== "opencode" ||
|
|
!runtimeNativeSnapshot
|
|
) {
|
|
return [];
|
|
}
|
|
const configuredDefault = runtimeCustomization?.opencode.defaultAgent;
|
|
return [
|
|
{
|
|
value: "",
|
|
label: configuredDefault
|
|
? t("composer.runtimeControls.configuredAgent", {
|
|
name: configuredDefault,
|
|
})
|
|
: t("composer.runtimeControls.runtimeDefaultAgent"),
|
|
description: t(
|
|
"composer.runtimeControls.runtimeDefaultAgentDescription",
|
|
),
|
|
},
|
|
...runtimeNativeSnapshot.agents
|
|
.filter(
|
|
(agent) =>
|
|
!agent.hidden && (agent.mode === "primary" || agent.mode === "all"),
|
|
)
|
|
.map((agent) => ({
|
|
value: agent.id,
|
|
label: agent.name,
|
|
description:
|
|
agent.description ?? t("composer.runtimeControls.agentDescription"),
|
|
})),
|
|
];
|
|
}, [
|
|
activeRuntimeSelection?.provider,
|
|
runtimeCustomization?.opencode.defaultAgent,
|
|
runtimeNativeSnapshot,
|
|
t,
|
|
]);
|
|
|
|
const runtimePresetOptions = useMemo<ComposerMenuOption<string>[]>(() => {
|
|
if (
|
|
activeRuntimeSelection?.provider !== "continue" ||
|
|
!runtimeCustomization
|
|
) {
|
|
return [];
|
|
}
|
|
return [
|
|
{
|
|
value: "",
|
|
label: t("composer.runtimeControls.noPreset"),
|
|
description: t("composer.runtimeControls.noPresetDescription"),
|
|
},
|
|
...runtimeCustomization.continue.presets.map((preset) => ({
|
|
value: preset.id,
|
|
label: preset.name,
|
|
description:
|
|
preset.description ??
|
|
t("composer.runtimeControls.presetDescription", {
|
|
rules: preset.rules.filter((rule) => rule.enabled).length,
|
|
prompts: preset.prompts.length,
|
|
}),
|
|
})),
|
|
];
|
|
}, [activeRuntimeSelection?.provider, runtimeCustomization, t]);
|
|
|
|
const runtimeActionOptions = useMemo<RuntimeActionChoice[]>(() => {
|
|
if (!runtimeNativeSnapshot) {
|
|
return [];
|
|
}
|
|
const nativePrompts = runtimeNativeSnapshot.prompts;
|
|
const selectedPreset =
|
|
activeRuntimeSelection?.provider === "continue"
|
|
? runtimeCustomization?.continue.presets.find(
|
|
(preset) =>
|
|
preset.id ===
|
|
(selectedContinuePreset ||
|
|
runtimeCustomization.continue.defaultPresetId),
|
|
)
|
|
: undefined;
|
|
return [
|
|
{
|
|
value: "",
|
|
label: t("composer.runtimeControls.noAction"),
|
|
description: t("composer.runtimeControls.noActionDescription"),
|
|
},
|
|
...(activeRuntimeSelection?.provider === "opencode"
|
|
? runtimeNativeSnapshot.commands.map((command) => ({
|
|
value: JSON.stringify(["command", command.id]),
|
|
label: `/${command.name}`,
|
|
description:
|
|
command.description ??
|
|
t("composer.runtimeControls.commandDescription"),
|
|
action: {
|
|
type: "command" as const,
|
|
id: command.id,
|
|
},
|
|
}))
|
|
: []),
|
|
...nativePrompts.map((prompt) => ({
|
|
value: JSON.stringify(["native-prompt", prompt.id]),
|
|
label: prompt.name,
|
|
description:
|
|
prompt.description ?? t("composer.runtimeControls.promptDescription"),
|
|
action: {
|
|
type: "prompt" as const,
|
|
prompt: prompt.prompt,
|
|
},
|
|
})),
|
|
...(selectedPreset?.prompts.map((prompt) => ({
|
|
value: JSON.stringify(["preset-prompt", selectedPreset.id, prompt.id]),
|
|
label: prompt.name,
|
|
description:
|
|
prompt.description ?? t("composer.runtimeControls.promptDescription"),
|
|
action: {
|
|
type: "prompt" as const,
|
|
prompt: prompt.prompt,
|
|
},
|
|
})) ?? []),
|
|
];
|
|
}, [
|
|
activeRuntimeSelection?.provider,
|
|
runtimeCustomization,
|
|
runtimeNativeSnapshot,
|
|
selectedContinuePreset,
|
|
t,
|
|
]);
|
|
|
|
const selectRuntimeAction = useCallback(
|
|
(value: string): void => {
|
|
if (!value) {
|
|
setSelectedRuntimeCommand("");
|
|
return;
|
|
}
|
|
const choice = runtimeActionOptions.find(
|
|
(candidate) => candidate.value === value,
|
|
);
|
|
if (choice?.action?.type === "command") {
|
|
setSelectedRuntimeCommand(choice.action.id);
|
|
return;
|
|
}
|
|
if (choice?.action?.type === "prompt") {
|
|
setInput(choice.action.prompt);
|
|
setSelectedRuntimeCommand("");
|
|
requestAnimationFrame(() => {
|
|
resizeComposerTextarea(inputRef.current);
|
|
inputRef.current?.focus();
|
|
});
|
|
}
|
|
},
|
|
[runtimeActionOptions, setInput],
|
|
);
|
|
// The committed active ID, or a just-created conversation until the next
|
|
// commit, so repeated new-conversation requests reuse it.
|
|
const conversationNavigationRef = useRef({ activeId });
|
|
|
|
useEffect(() => {
|
|
conversationNavigationRef.current = { activeId };
|
|
}, [activeId]);
|
|
|
|
useEffect(() => {
|
|
const selection = activeRuntimeSelectionRef.current;
|
|
if (!selection || !runtimeSettings) {
|
|
return;
|
|
}
|
|
if (
|
|
runtimeStatusCacheRef.current?.key === activeRuntimeSelectionKey &&
|
|
runtimeStatusCacheRef.current.settings === runtimeSettings
|
|
) {
|
|
return;
|
|
}
|
|
runtimeStatusCacheRef.current = {
|
|
key: activeRuntimeSelectionKey,
|
|
settings: runtimeSettings,
|
|
};
|
|
const requestId = runtimeStatusRequestRef.current + 1;
|
|
runtimeStatusRequestRef.current = requestId;
|
|
setRuntimeSwitching(false);
|
|
setRuntimeStatusKey("");
|
|
void window.goodbuddy.agent
|
|
.getStatus(selection)
|
|
.then((status) => {
|
|
if (runtimeStatusRequestRef.current !== requestId) {
|
|
return;
|
|
}
|
|
setRuntime(status);
|
|
setRuntimeStatusKey(activeRuntimeSelectionKey);
|
|
if (!status.available) {
|
|
notify({
|
|
tone: "error",
|
|
message: tRef.current("runtime.selectionUnavailable", {
|
|
label: status.label,
|
|
detail: status.detail,
|
|
}),
|
|
dedupeKey: "runtime-status",
|
|
});
|
|
}
|
|
if (!status.available && !runtimeSetupPromptedRef.current) {
|
|
runtimeSetupPromptedRef.current = true;
|
|
setView("settings");
|
|
}
|
|
})
|
|
.catch((reason: unknown) => {
|
|
if (runtimeStatusRequestRef.current !== requestId) {
|
|
return;
|
|
}
|
|
const detail = reason instanceof Error
|
|
? reason.message
|
|
: tRef.current("runtime.errors.readStatus");
|
|
setRuntime({
|
|
id: "setup",
|
|
label: tRef.current("runtime.unavailable"),
|
|
available: false,
|
|
supportsToolExecution: false,
|
|
detail,
|
|
});
|
|
setRuntimeStatusKey(activeRuntimeSelectionKey);
|
|
notify({ tone: "error", message: detail, dedupeKey: "runtime-status" });
|
|
});
|
|
}, [activeRuntimeSelectionKey, runtimeSettings, setView, notify]);
|
|
|
|
const startNewConversation = useCallback(
|
|
(projectId?: string, preview?: { ready: (conversation: Conversation) => void }): boolean => {
|
|
const project = projects.find((candidate) => candidate.id === projectId);
|
|
if (project?.kind === "channel") {
|
|
if (!preview) setView("chat");
|
|
notify({
|
|
tone: "info",
|
|
message: tRef.current("notices.channelConversationAutomatic"),
|
|
dedupeKey: "channel-project-new-conversation",
|
|
});
|
|
return false;
|
|
}
|
|
const navigation = conversationNavigationRef.current;
|
|
const currentConversation = conversationStore.getConversation(navigation.activeId);
|
|
if (
|
|
currentConversation &&
|
|
currentConversation.projectId === projectId &&
|
|
isUnusedConversation(currentConversation)
|
|
) {
|
|
if (preview) preview.ready(currentConversation);
|
|
else showChatAndFocusComposer();
|
|
return true;
|
|
}
|
|
const conversation = createConversation(
|
|
projectId,
|
|
undefined,
|
|
tRef.current("conversation.greeting"),
|
|
);
|
|
conversationNavigationRef.current = { activeId: conversation.id };
|
|
setConversations((current) => [conversation, ...current]);
|
|
if (preview) preview.ready(conversation);
|
|
else { setActiveId(conversation.id); showChatAndFocusComposer(); }
|
|
return true;
|
|
},
|
|
[notify, projects, setActiveId, setView, showChatAndFocusComposer, setConversations, conversationStore],
|
|
);
|
|
const activeProjectDisplayName = activeProject
|
|
? getProjectDisplayText(activeProject, tWorkspace).name
|
|
: undefined;
|
|
const queuedConversationIds = useMemo(
|
|
() => new Set(conversationQueueItems.map((item) => item.conversationId)),
|
|
[conversationQueueItems],
|
|
);
|
|
const productAssistantTasks = useProductTasks(taskStore);
|
|
const taskStatusRows = useTaskStatusRows(taskStore);
|
|
const taskActivityRows = useTaskActivityRows(taskStore);
|
|
// The supervisor page needs every task; App follows them only while it is shown.
|
|
const heartbeatTasks = useAllTasks(taskStore, view !== "heartbeat");
|
|
const executionStatsEnabled = assistantSidebarOpen && assistantSidebarTab === "tasks";
|
|
const statsConversation = activeConversation?.projectId === activeProjectId
|
|
? activeConversation : undefined;
|
|
const statsMessageCount = statsConversation?.messageCount ?? 0;
|
|
const executionStats = useExecutionStats(
|
|
statsConversation?.id,
|
|
activeProjectId || undefined,
|
|
executionStatsEnabled,
|
|
);
|
|
const taskDurations = useMemo(() => new Map(
|
|
executionStats.project?.taskDurations.map((task) => [task.id, {
|
|
durationMs: task.durationMs,
|
|
incomplete: task.incomplete,
|
|
}]) ?? [],
|
|
), [executionStats.project]);
|
|
const tasksByConversation = useMemo(() => {
|
|
const grouped = new Map<string, AssistantTask[]>();
|
|
for (const task of productAssistantTasks) {
|
|
if (!task.conversationId) {
|
|
continue;
|
|
}
|
|
const existing = grouped.get(task.conversationId) ?? [];
|
|
existing.push(task);
|
|
grouped.set(task.conversationId, existing);
|
|
}
|
|
for (const tasks of grouped.values()) {
|
|
tasks.sort((left, right) =>
|
|
right.createdAt.localeCompare(left.createdAt),
|
|
);
|
|
}
|
|
return grouped;
|
|
}, [productAssistantTasks]);
|
|
const conversationTitles = useConversationTitles(conversationStore, t("conversation.defaultTitle"));
|
|
const projectNames = useMemo(
|
|
() =>
|
|
new Map(
|
|
projects.map((project) => [
|
|
project.id,
|
|
getProjectDisplayText(project, tWorkspace).name,
|
|
]),
|
|
),
|
|
[projects, tWorkspace],
|
|
);
|
|
const { completedConversationIds, markConversationCompleted, clearConversationCompleted } =
|
|
useUnviewedCompletions(taskStatusRows,
|
|
view === "chat" && !settingsOpen && !applicationCenterOpen && activeConversation?.historyLoaded
|
|
? activeId : undefined);
|
|
const activityProjects = useMemo(
|
|
() => projects.map((project) => ({
|
|
id: project.id,
|
|
name: projectNames.get(project.id) ?? project.name,
|
|
})),
|
|
[projects, projectNames],
|
|
);
|
|
const projectActivity = useConversationActivitySummary(conversationStore, {
|
|
activeConversationIds,
|
|
completedConversationIds,
|
|
defaultTitle: t("conversation.defaultTitle"),
|
|
fallbackProjectName: tWorkspace("projectActivity.unassigned"),
|
|
projects: activityProjects,
|
|
tasks: taskActivityRows,
|
|
});
|
|
const activityByConversationId = useMemo(
|
|
() =>
|
|
new Map(
|
|
projectActivity.activities.filter((activity) => activity.status !== "completed").map((activity) => [
|
|
activity.conversationId,
|
|
activity,
|
|
]),
|
|
),
|
|
[projectActivity],
|
|
);
|
|
useLayoutEffect(() => {
|
|
busyConversationIdsRef.current = new Set([...activityByConversationId.keys(), ...queuedConversationIds]);
|
|
}, [activityByConversationId, queuedConversationIds]);
|
|
const pendingSidebarApprovals = usePendingSidebarApprovals(conversationStore);
|
|
// Pending supervisor suggestions; earlier report proposals are migrated into them.
|
|
const [pendingHeartbeatSuggestionCount, setPendingHeartbeatSuggestionCount] = useState(0);
|
|
|
|
const updateMessage = useCallback(
|
|
(
|
|
conversationId: string,
|
|
messageId: string,
|
|
update: (message: Message) => Message,
|
|
): void => {
|
|
setConversations((current) => {
|
|
const conversationIndex = current.findIndex(item => item.id === conversationId);
|
|
const conversation = current[conversationIndex];
|
|
if (!conversation) return current;
|
|
const messageIndex = conversation.messages.findIndex(message => message.id === messageId);
|
|
const message = conversation.messages[messageIndex];
|
|
if (!message) return current;
|
|
const updated = update(message);
|
|
if (updated === message) return current;
|
|
const messages = [...conversation.messages];
|
|
messages[messageIndex] = updated;
|
|
const next = [...current];
|
|
next[conversationIndex] = { ...conversation, updatedAt: Date.now(), messages };
|
|
return next;
|
|
});
|
|
},
|
|
[setConversations],
|
|
);
|
|
|
|
const recordActivity = useCallback(
|
|
(
|
|
record: Omit<ActivityRecord, "id" | "createdAt" | "scope">,
|
|
scopeOverride?: ActivityRecord["scope"],
|
|
): void => {
|
|
const conversation = conversationStore.getState().find(
|
|
(candidate) => candidate.id === record.conversationId,
|
|
);
|
|
const project = conversation?.projectId
|
|
? projectsRef.current.find(
|
|
(candidate) => candidate.id === conversation.projectId,
|
|
)
|
|
: undefined;
|
|
const scope: ActivityRecord["scope"] =
|
|
scopeOverride ??
|
|
(!conversation
|
|
? { kind: "unavailable" }
|
|
: !conversation.projectId
|
|
? { kind: "global" }
|
|
: project?.id && project.name
|
|
? {
|
|
kind: "project",
|
|
projectId: project.id.slice(0, 256),
|
|
projectName: project.name.slice(0, 120),
|
|
}
|
|
: { kind: "unavailable" });
|
|
activityStore.record({
|
|
...record,
|
|
title: record.title.slice(0, 240),
|
|
scope,
|
|
id: crypto.randomUUID(),
|
|
createdAt: Date.now(),
|
|
});
|
|
},
|
|
[activityStore, conversationStore],
|
|
);
|
|
|
|
const updateRequestActivity = activityStore.updateRequest;
|
|
|
|
useEffect(() => {
|
|
const api = window.goodbuddy.channels;
|
|
if (!api) {
|
|
return;
|
|
}
|
|
return api.onRemoteActivity((activity) => {
|
|
if (activity.kind === "result") {
|
|
updateRequestActivity(
|
|
activity.requestId,
|
|
activity.status,
|
|
activity.detail,
|
|
);
|
|
}
|
|
recordActivity(
|
|
{
|
|
requestId: activity.requestId,
|
|
conversationId: activity.conversationId,
|
|
callId: activity.callId,
|
|
kind: activity.kind,
|
|
title: activity.title,
|
|
detail: activity.detail,
|
|
status: activity.status,
|
|
},
|
|
{
|
|
kind: "project",
|
|
projectId: activity.projectId.slice(0, 256),
|
|
projectName: activity.projectName.slice(0, 120),
|
|
},
|
|
);
|
|
});
|
|
}, [recordActivity, updateRequestActivity]);
|
|
|
|
const refreshKnowledge = useCallback(
|
|
async (libraryId?: string): Promise<KnowledgeSnapshot> => {
|
|
const requestId = ++knowledgeLoadRequestRef.current;
|
|
try {
|
|
const [snapshot, instances] = await Promise.all([
|
|
window.goodbuddy.knowledge.getSnapshot(libraryId),
|
|
window.goodbuddy.knowledge.externalInstancesList(),
|
|
]);
|
|
if (requestId !== knowledgeLoadRequestRef.current) {
|
|
return snapshot;
|
|
}
|
|
failedKnowledgeLibraryIdRef.current = undefined;
|
|
setKnowledgeSnapshot(snapshot);
|
|
setExternalInstances(instances);
|
|
setKnowledgeLoadError(undefined);
|
|
const availableIds = new Set(
|
|
snapshot.libraries.map((library) => library.id),
|
|
);
|
|
setConversations((current) =>
|
|
current.map((conversation) => {
|
|
const previous = conversation.knowledgeLibraryIds ?? [];
|
|
const next = previous.filter((id) => availableIds.has(id));
|
|
return previous.length === next.length
|
|
? conversation
|
|
: {
|
|
...conversation,
|
|
knowledgeLibraryIds: next,
|
|
updatedAt: Date.now(),
|
|
};
|
|
}),
|
|
);
|
|
return snapshot;
|
|
} catch (reason) {
|
|
if (requestId !== knowledgeLoadRequestRef.current) {
|
|
throw reason;
|
|
}
|
|
failedKnowledgeLibraryIdRef.current = libraryId;
|
|
setKnowledgeLoadError(
|
|
displayErrorMessage(
|
|
reason,
|
|
tRef.current("notices.knowledgeReadFailed"),
|
|
),
|
|
);
|
|
throw reason;
|
|
}
|
|
},
|
|
[setConversations],
|
|
);
|
|
|
|
const retryKnowledgeLoad = useCallback(async (): Promise<void> => {
|
|
setKnowledgeLoading(true);
|
|
setKnowledgeLoadError(undefined);
|
|
try {
|
|
await refreshKnowledge(failedKnowledgeLibraryIdRef.current);
|
|
} catch {
|
|
// The recoverable page state is set by refreshKnowledge.
|
|
} finally {
|
|
setKnowledgeLoading(false);
|
|
}
|
|
}, [refreshKnowledge]);
|
|
|
|
/** Writes the conversation layer (undefined = follow the project) and refreshes status. */
|
|
const switchRuntime = useCallback(
|
|
async (layer: RuntimeSelectionLayer | undefined): Promise<void> => {
|
|
if (!runtimeSettings || !activeConversation || runtimeSwitching) {
|
|
return;
|
|
}
|
|
const nextLayer = compactRuntimeSelectionLayer(layer);
|
|
const resolved = resolveConversationRuntime(
|
|
activeProject,
|
|
nextLayer,
|
|
runtimeSettings,
|
|
);
|
|
const selection = resolved.selection;
|
|
runtimeMenuButtonRef.current?.focus();
|
|
setRuntimeSwitching(true);
|
|
composerMenus.closeRuntimeMenu();
|
|
const requestId = runtimeStatusRequestRef.current + 1;
|
|
runtimeStatusRequestRef.current = requestId;
|
|
const generation = runtimeSwitchGenerationRef.current;
|
|
try {
|
|
const status = await window.goodbuddy.agent.getStatus(selection);
|
|
if (
|
|
runtimeStatusRequestRef.current !== requestId ||
|
|
runtimeSwitchGenerationRef.current !== generation
|
|
) {
|
|
return;
|
|
}
|
|
const selectionKey = agentRuntimeSelectionKey(selection);
|
|
runtimeStatusCacheRef.current = {
|
|
key: selectionKey,
|
|
settings: runtimeSettings,
|
|
};
|
|
const label = runtimeChoiceLabel(
|
|
resolved,
|
|
runtimeSettings,
|
|
status,
|
|
tRef.current,
|
|
);
|
|
setConversations((current) =>
|
|
current.map((conversation) =>
|
|
conversation.id === activeConversation.id
|
|
? {
|
|
...conversation,
|
|
runtimeSelection: nextLayer,
|
|
updatedAt: Date.now(),
|
|
}
|
|
: conversation,
|
|
),
|
|
);
|
|
setRuntime(status);
|
|
setRuntimeStatusKey(selectionKey);
|
|
notify({
|
|
tone: status.available ? "success" : "error",
|
|
message: status.available
|
|
? tRef.current("runtime.switched", { label })
|
|
: tRef.current("runtime.selectionUnavailable", {
|
|
label,
|
|
detail: status.detail,
|
|
}),
|
|
dedupeKey: "runtime-switch",
|
|
});
|
|
} catch (reason) {
|
|
if (
|
|
runtimeStatusRequestRef.current !== requestId ||
|
|
runtimeSwitchGenerationRef.current !== generation
|
|
) {
|
|
return;
|
|
}
|
|
notify({
|
|
tone: "error",
|
|
message:
|
|
reason instanceof Error
|
|
? reason.message
|
|
: tRef.current("runtime.errors.switch"),
|
|
dedupeKey: "runtime-switch",
|
|
});
|
|
} finally {
|
|
if (
|
|
runtimeStatusRequestRef.current === requestId &&
|
|
runtimeSwitchGenerationRef.current === generation
|
|
) {
|
|
setRuntimeSwitching(false);
|
|
requestAnimationFrame(() => {
|
|
runtimeMenuButtonRef.current?.focus();
|
|
});
|
|
}
|
|
}
|
|
},
|
|
[
|
|
activeConversation,
|
|
activeProject,
|
|
composerMenus,
|
|
runtimeSettings,
|
|
runtimeSwitching,
|
|
setConversations,
|
|
],
|
|
);
|
|
|
|
const refreshTokenUsage = useCallback(async (): Promise<void> => {
|
|
setTokenUsage(await window.goodbuddy.usage.getTokenSummary());
|
|
}, []);
|
|
|
|
const loadWorkspaceChanges = useCallback(
|
|
async (projectId: string): Promise<void> => {
|
|
const requestId = workspaceChangesRequestRef.current + 1;
|
|
workspaceChangesRequestRef.current = requestId;
|
|
const changes = await window.goodbuddy.workspace.getChanges(projectId);
|
|
if (
|
|
workspaceChangesRequestRef.current === requestId &&
|
|
activeProjectIdRef.current === projectId
|
|
) {
|
|
setWorkspaceChanges((current) => ({
|
|
projectId,
|
|
changes:
|
|
changes.error &&
|
|
current?.projectId === projectId &&
|
|
current.changes.available
|
|
? { ...current.changes, error: changes.error }
|
|
: changes,
|
|
}));
|
|
}
|
|
},
|
|
[],
|
|
);
|
|
|
|
const releaseConversationQueueAfterRun = useCallback(
|
|
(run: Pick<ActiveRun, "conversationId" | "projectId">): void => {
|
|
requestAnimationFrame(() => {
|
|
if (
|
|
run.projectId &&
|
|
((!projectRecoverySnapshotReadyRef.current &&
|
|
isManagedSshProject(
|
|
projectsRef.current.find(
|
|
(project) => project.id === run.projectId,
|
|
),
|
|
)) ||
|
|
isProjectRecoveryUnsettled(
|
|
projectRecoveryByProjectIdRef.current[run.projectId],
|
|
))
|
|
) {
|
|
return;
|
|
}
|
|
void window.goodbuddy.conversationQueue
|
|
.ready(run.conversationId)
|
|
.catch(() => {
|
|
notify({
|
|
tone: "error",
|
|
message: tRef.current("notices.conversationQueueResumeFailed"),
|
|
dedupeKey: "conversation-queue-resume",
|
|
});
|
|
});
|
|
});
|
|
},
|
|
[notify],
|
|
);
|
|
|
|
// Event handling lives in agent-event-handler.ts; the listener stays
|
|
// subscribed and reads the latest setters and refs, updated after commit.
|
|
const agentEventDependenciesRef = useRef<AgentEventDependencies | undefined>(undefined);
|
|
useLayoutEffect(() => {
|
|
agentEventDependenciesRef.current = {
|
|
activeRuns, activeConversationIdRef, activeProjectIdRef, taskStore, hydratingArtifactIds,
|
|
requestPersistenceFlush: conversationPersistence.requestFlushAfterCommit, tRef,
|
|
conversationStore, liveMessages, setConversations,
|
|
activityStore, setUnreadConversationIds, notify, updateMessage, recordActivity,
|
|
loadWorkspaceChanges, markConversationCompleted, setConversationActivity,
|
|
releaseConversationQueueAfterRun,
|
|
};
|
|
}, [activityStore, conversationPersistence, conversationStore, liveMessages, setConversations, taskStore,
|
|
updateMessage, recordActivity, loadWorkspaceChanges, markConversationCompleted,
|
|
setConversationActivity, releaseConversationQueueAfterRun]);
|
|
const handleAgentEvent = useCallback((event: AgentEvent): void => {
|
|
const dependencies = agentEventDependenciesRef.current;
|
|
if (dependencies) applyAgentEvent(event, dependencies);
|
|
}, []);
|
|
|
|
useEffect(() => {
|
|
activeProjectIdRef.current = activeProjectId;
|
|
if (activeProjectId) {
|
|
try {
|
|
localStorage.setItem(activeProjectStorageKey, activeProjectId);
|
|
} catch {
|
|
// The project selection still works when persistence is unavailable.
|
|
}
|
|
}
|
|
}, [activeProjectId]);
|
|
|
|
useEffect(() => {
|
|
viewRef.current = view;
|
|
}, [view]);
|
|
|
|
const retainedConversationDetailIds = useCallback((): Set<string> => new Set([
|
|
activeConversationIdRef.current,
|
|
...cachedConversationViewsRef.current.map(entry => entry.key),
|
|
...[...activeRuns.current.values()].map(run => run.conversationId),
|
|
...preparingConversations.current,
|
|
].filter(Boolean)), []);
|
|
useLayoutEffect(() => {
|
|
conversationPersistence.connect({
|
|
retainedConversationIds: retainedConversationDetailIds,
|
|
hasBusyTask: (conversationId) => taskStore.getTasks().some(task => task.conversationId === conversationId &&
|
|
(task.status === "running" || task.status === "waiting_approval")),
|
|
pinState: () => ({ revision: conversationPinRevisionRef.current, pending: conversationPinPendingRef.current }),
|
|
historyUnavailableError: () => new Error(tRef.current("notices.remoteConversationRefreshFailed")),
|
|
onSaveFailed: () => notify({
|
|
tone: "error",
|
|
message: tRef.current("notices.conversationPersistenceFailed"),
|
|
dedupeKey: "conversation-persistence",
|
|
}),
|
|
});
|
|
}, [conversationPersistence, retainedConversationDetailIds, taskStore]);
|
|
// Saves, history loading and the save queue live in conversation-persistence.ts.
|
|
const persistLocalConversationChanges = conversationPersistence.persist;
|
|
const ensureConversationHistory = conversationPersistence.ensureHistory;
|
|
const flushConversationPersistenceAfterCommit = conversationPersistence.flushAfterCommit;
|
|
|
|
useEffect(() => {
|
|
if (!conversationStoreReady) return;
|
|
// Reuse the view cache's lifetime. Release only acknowledged, idle history,
|
|
// including its persistence reference, never unsaved or executing messages.
|
|
persistLocalConversationChanges();
|
|
}, [cachedConversationViews, conversationStoreReady, persistLocalConversationChanges]);
|
|
|
|
useEffect(() => {
|
|
if (!conversationStoreReady) {
|
|
return;
|
|
}
|
|
const stop = conversationPersistence.start();
|
|
conversationPersistence.flushAfterCommit();
|
|
return stop;
|
|
}, [conversationStoreReady, conversationPersistence]);
|
|
|
|
const activitySync = useActivityHistorySync(activityStore, legacyActivityHistory, {
|
|
activeRequestIds: () => new Set(activeRuns.current.keys()),
|
|
onReadFailed: () => notify({
|
|
tone: "error", message: tRef.current("notices.activityHistoryReadFailed"), dedupeKey: "activity-history-read",
|
|
}),
|
|
onSaveFailed: () => notify({
|
|
tone: "error",
|
|
message: tRef.current("notices.activityHistoryPersistenceFailed"),
|
|
dedupeKey: "activity-history-persistence",
|
|
}),
|
|
// The loaded history appears at once when the Activity page is open.
|
|
onLoaded: () => {
|
|
if (viewRef.current === "activity") void activitySync.show();
|
|
},
|
|
});
|
|
const persistActivityHistory = activitySync.flush;
|
|
|
|
useEffect(
|
|
() =>
|
|
window.goodbuddy.app.onBeforeQuit(async () => {
|
|
await persistActivityHistory();
|
|
if (!conversationStoreReady) {
|
|
return;
|
|
}
|
|
await conversationPersistence.flushForQuit();
|
|
await attachmentSaveQueue.current;
|
|
}),
|
|
[conversationStoreReady, persistActivityHistory, conversationPersistence],
|
|
);
|
|
|
|
// Main's "data changed" notifications: conversation-refresh.ts re-reads
|
|
// tasks, schedules and summaries and merges them into the store.
|
|
useEffect(() => {
|
|
if (!conversationStoreReady) {
|
|
return;
|
|
}
|
|
return startConversationRefresh({
|
|
store: conversationStore,
|
|
persistence: conversationPersistence,
|
|
activeRuns: activeRuns.current,
|
|
activeConversationId: () => activeConversationIdRef.current,
|
|
retainedConversationIds: retainedConversationDetailIds,
|
|
pinState: () => ({
|
|
revision: conversationPinRevisionRef.current,
|
|
pending: conversationPinPendingRef.current,
|
|
}),
|
|
onTasks: (tasks) => {
|
|
setAssistantTasks(tasks);
|
|
activityStore.reconcile(tasks, new Set(activeRuns.current.keys()));
|
|
},
|
|
onSchedules: setAssistantSchedules,
|
|
onUnread: (unread) => {
|
|
setUnreadConversationIds((current) => {
|
|
const next = new Set(current);
|
|
unread.forEach((conversation) => next.add(conversation.id));
|
|
return next;
|
|
});
|
|
notify({
|
|
tone: "info",
|
|
message: tRef.current("notices.remoteMessage", {
|
|
channel: projectChannelLabels[unread[0]!.remote!.channel],
|
|
}),
|
|
dedupeKey: "remote-channel-message",
|
|
});
|
|
},
|
|
onRunSettled: (_requestId, run, state) => {
|
|
if (state === "complete") markConversationCompleted(run.conversationId);
|
|
setConversationActivity(run.conversationId, false);
|
|
releaseConversationQueueAfterRun(run);
|
|
},
|
|
onError: (kind) => {
|
|
notify(kind === "tasks"
|
|
? { tone: "error", message: tRef.current("notices.taskHistoryReadFailed"), dedupeKey: "task-lifecycle-refresh" }
|
|
: kind === "schedules"
|
|
? { tone: "error", message: tRef.current("notices.schedulesReadFailed"), dedupeKey: "schedule-lifecycle-refresh" }
|
|
: { tone: "error", message: tRef.current("notices.remoteConversationRefreshFailed"), dedupeKey: "remote-conversation-refresh" });
|
|
},
|
|
});
|
|
}, [
|
|
activityStore,
|
|
conversationStore,
|
|
conversationPersistence,
|
|
conversationStoreReady,
|
|
releaseConversationQueueAfterRun,
|
|
retainedConversationDetailIds,
|
|
setAssistantTasks,
|
|
setConversationActivity,
|
|
markConversationCompleted,
|
|
]);
|
|
|
|
useEffect(() => {
|
|
let active = true;
|
|
let refreshInFlight = false;
|
|
let refreshQueued = false;
|
|
let refreshTimer: number | undefined;
|
|
let refreshAll = false;
|
|
const pendingConversationIds = new Set<string>();
|
|
const scheduleRefresh = (): void => {
|
|
if (refreshTimer !== undefined || refreshInFlight) {
|
|
refreshQueued = true;
|
|
return;
|
|
}
|
|
refreshTimer = window.setTimeout(() => {
|
|
refreshTimer = undefined;
|
|
refreshQueued = false;
|
|
const conversationIds = refreshAll
|
|
? undefined
|
|
: [...pendingConversationIds];
|
|
refreshAll = false;
|
|
pendingConversationIds.clear();
|
|
refresh(conversationIds);
|
|
}, 0);
|
|
};
|
|
const refresh = (conversationIds?: string[]): void => {
|
|
refreshInFlight = true;
|
|
const affectedConversationIds = new Set(conversationIds ?? []);
|
|
const reads = conversationIds
|
|
? conversationIds.map(async (conversationId) => ({
|
|
conversationId,
|
|
items:
|
|
await window.goodbuddy.conversationQueue.list(conversationId),
|
|
}))
|
|
: [
|
|
window.goodbuddy.conversationQueue.list().then((items) => ({
|
|
conversationId: undefined,
|
|
items,
|
|
})),
|
|
];
|
|
void Promise.all(reads)
|
|
.then((results) => {
|
|
if (!active) {
|
|
return;
|
|
}
|
|
setConversationQueueItems((current) => {
|
|
const allItems = results.find(
|
|
(result) => result.conversationId === undefined,
|
|
)?.items;
|
|
const next = allItems
|
|
? allItems
|
|
: [
|
|
...current.filter(
|
|
(item) => !affectedConversationIds.has(item.conversationId),
|
|
),
|
|
...results.flatMap((result) => result.items),
|
|
].sort(
|
|
(left, right) =>
|
|
left.createdAt.localeCompare(right.createdAt) ||
|
|
left.id.localeCompare(right.id),
|
|
);
|
|
return sameConversationQueueItems(current, next) ? current : next;
|
|
});
|
|
})
|
|
.catch(() => {
|
|
if (active) {
|
|
notify({
|
|
tone: "error",
|
|
message: tRef.current("notices.conversationQueueReadFailed"),
|
|
dedupeKey: "conversation-queue-read",
|
|
});
|
|
}
|
|
})
|
|
.finally(() => {
|
|
refreshInFlight = false;
|
|
if (active && refreshQueued) {
|
|
refreshQueued = false;
|
|
scheduleRefresh();
|
|
}
|
|
});
|
|
};
|
|
const queueRefresh = (conversationId?: string): void => {
|
|
if (conversationId) {
|
|
pendingConversationIds.add(conversationId);
|
|
} else {
|
|
refreshAll = true;
|
|
}
|
|
scheduleRefresh();
|
|
};
|
|
refresh();
|
|
const remove = window.goodbuddy.conversationQueue.onChanged(queueRefresh);
|
|
const removeDispatch = window.goodbuddy.conversationQueue.onDispatch(
|
|
(dispatch) => conversationQueueDispatchRef.current(dispatch),
|
|
);
|
|
return () => {
|
|
active = false;
|
|
if (refreshTimer !== undefined) {
|
|
window.clearTimeout(refreshTimer);
|
|
}
|
|
remove();
|
|
removeDispatch();
|
|
};
|
|
}, []);
|
|
|
|
const { show: showActivity, hide: hideActivity } = activitySync;
|
|
const refreshActivityPanelRecords = useCallback((): void => void showActivity(), [showActivity]);
|
|
|
|
// Layout effect so entering the page never paints a stale snapshot; leaving
|
|
// it keeps only the first page loaded.
|
|
useLayoutEffect(() => {
|
|
if (view !== "activity") {
|
|
return;
|
|
}
|
|
refreshActivityPanelRecords();
|
|
const interval = window.setInterval(
|
|
refreshActivityPanelRecords,
|
|
activityPanelRefreshIntervalMs,
|
|
);
|
|
return () => {
|
|
window.clearInterval(interval);
|
|
hideActivity();
|
|
};
|
|
}, [hideActivity, refreshActivityPanelRecords, view]);
|
|
|
|
const resumeProjectConversationQueues = useCallback(
|
|
(projectId: string): void => {
|
|
if (
|
|
(!projectRecoverySnapshotReadyRef.current &&
|
|
isManagedSshProject(
|
|
projectsRef.current.find((project) => project.id === projectId),
|
|
)) ||
|
|
isProjectRecoveryUnsettled(
|
|
projectRecoveryByProjectIdRef.current[projectId],
|
|
)
|
|
) {
|
|
return;
|
|
}
|
|
const conversationIds = conversationStore.getState()
|
|
.filter(
|
|
(conversation) =>
|
|
conversation.projectId === projectId && !conversation.remote,
|
|
)
|
|
.map((conversation) => conversation.id);
|
|
if (conversationIds.length === 0) {
|
|
return;
|
|
}
|
|
void Promise.all(
|
|
conversationIds.map((conversationId) =>
|
|
window.goodbuddy.conversationQueue.ready(conversationId),
|
|
),
|
|
).catch(() => {
|
|
notify({
|
|
tone: "error",
|
|
message: tRef.current("notices.conversationQueueResumeFailed"),
|
|
dedupeKey: `conversation-queue-resume:${projectId}`,
|
|
});
|
|
});
|
|
},
|
|
[notify, conversationStore],
|
|
);
|
|
|
|
const applyProjectRecoveryState = useCallback(
|
|
(state: RemoteProjectRecoveryState): void => {
|
|
const previous = projectRecoveryByProjectIdRef.current[state.projectId];
|
|
if (previous) {
|
|
if (previous.requestId !== state.requestId) {
|
|
if (
|
|
!["completed", "failed"].includes(previous.stage) ||
|
|
state.stage !== "network"
|
|
) {
|
|
return;
|
|
}
|
|
} else if (
|
|
remoteRecoveryStageOrder(state.stage) <
|
|
remoteRecoveryStageOrder(previous.stage) ||
|
|
(previous.stage === "cursor" &&
|
|
state.stage === "cursor" &&
|
|
BigInt(state.current) < BigInt(previous.current)) ||
|
|
["completed", "failed"].includes(previous.stage)
|
|
) {
|
|
return;
|
|
}
|
|
}
|
|
const next = {
|
|
...projectRecoveryByProjectIdRef.current,
|
|
[state.projectId]: state,
|
|
};
|
|
projectRecoveryByProjectIdRef.current = next;
|
|
setProjectRecoveryByProjectId(next);
|
|
if (state.stage === "completed" && previous?.stage !== "completed") {
|
|
resumeProjectConversationQueues(state.projectId);
|
|
}
|
|
},
|
|
[resumeProjectConversationQueues],
|
|
);
|
|
|
|
useEffect(() => {
|
|
const recoveryApi = window.goodbuddy.projects.remote;
|
|
let active = true;
|
|
const removeListener = recoveryApi.onRecoveryProgress((state) => {
|
|
if (active) {
|
|
applyProjectRecoveryState(state);
|
|
}
|
|
});
|
|
void recoveryApi.getRecoverySnapshot().then(
|
|
(snapshot) => {
|
|
if (active) {
|
|
snapshot.recoveries.forEach(applyProjectRecoveryState);
|
|
projectRecoverySnapshotReadyRef.current = true;
|
|
setProjectRecoverySnapshotReady(true);
|
|
}
|
|
},
|
|
() => {
|
|
// Main reports actionable recovery failures as project states.
|
|
if (active) {
|
|
projectRecoverySnapshotReadyRef.current = true;
|
|
setProjectRecoverySnapshotReady(true);
|
|
}
|
|
},
|
|
);
|
|
return () => {
|
|
active = false;
|
|
removeListener();
|
|
};
|
|
}, [applyProjectRecoveryState]);
|
|
|
|
const retryProjectRecovery = useCallback(
|
|
async (projectId: string): Promise<void> => {
|
|
if (retryingRecoveryProjectIdsRef.current.has(projectId)) {
|
|
return;
|
|
}
|
|
retryingRecoveryProjectIdsRef.current.add(projectId);
|
|
try {
|
|
const state =
|
|
await window.goodbuddy.projects.remote.retryRecovery(projectId);
|
|
applyProjectRecoveryState(state);
|
|
} catch {
|
|
// Preserve the existing local failure without duplicating a toast.
|
|
} finally {
|
|
retryingRecoveryProjectIdsRef.current.delete(projectId);
|
|
}
|
|
},
|
|
[applyProjectRecoveryState],
|
|
);
|
|
|
|
useEffect(() => {
|
|
let active = true;
|
|
const initialization = Promise.all([
|
|
window.goodbuddy.projects.list(false),
|
|
window.goodbuddy.conversations.listSummaries(),
|
|
]).then(async ([value, persistedConversations]) => {
|
|
if (!active || value.length === 0) {
|
|
return;
|
|
}
|
|
setProjects(value);
|
|
const project = value.find(isOrdinaryLocalProject);
|
|
if (!project) {
|
|
throw new Error("没有可用的本地项目");
|
|
}
|
|
setActiveProjectId(project.id);
|
|
const initialConversation = persistedConversations.find(item => item.projectId === project.id);
|
|
if (initialConversation?.messageSummary) {
|
|
const detail = await window.goodbuddy.conversations.get(initialConversation.id);
|
|
persistedConversations = persistedConversations.map(item => item.id === detail.id ? detail : item);
|
|
}
|
|
const persistedLocalConversations = persistedConversations.filter(
|
|
(conversation) => !conversation.remote,
|
|
);
|
|
const persistedConversationIds = new Set(
|
|
persistedConversations.map((conversation) => conversation.id),
|
|
);
|
|
const shouldMigrateLocalStorage =
|
|
conversationMigrationStoragePresent.current ||
|
|
persistedConversations.length === 0;
|
|
const migratedLocalConversations = shouldMigrateLocalStorage
|
|
? migrationConversations.current
|
|
.filter(
|
|
(conversation) =>
|
|
!conversation.remote &&
|
|
!persistedConversationIds.has(conversation.id),
|
|
)
|
|
.map((conversation) =>
|
|
conversation.projectId || project.kind === "channel"
|
|
? conversation
|
|
: { ...conversation, projectId: project.id },
|
|
)
|
|
: [];
|
|
let nextConversations: Conversation[] = [
|
|
...persistedConversations.map(withRecoveredQuestions),
|
|
...migratedLocalConversations,
|
|
];
|
|
let projectConversation = nextConversations.find(
|
|
(conversation) =>
|
|
conversation.projectId === project.id &&
|
|
(project.kind !== "channel" || conversation.remote !== undefined),
|
|
);
|
|
if (!projectConversation && project.kind !== "channel") {
|
|
projectConversation = createConversation(
|
|
project.id,
|
|
undefined,
|
|
tRef.current("conversation.greeting"),
|
|
);
|
|
nextConversations = [projectConversation, ...nextConversations];
|
|
}
|
|
const acknowledgedLocalConversations = new Map(
|
|
persistedLocalConversations.map((conversation) => [
|
|
conversation.id,
|
|
conversation,
|
|
]),
|
|
);
|
|
if (
|
|
nextConversations.some(
|
|
(conversation) =>
|
|
!conversation.remote &&
|
|
acknowledgedLocalConversations.get(conversation.id) !==
|
|
conversation,
|
|
)
|
|
) {
|
|
if (persistedConversations.length === 0) {
|
|
const migratedSnapshots = toConversationSnapshots(nextConversations);
|
|
await window.goodbuddy.conversations.replace(migratedSnapshots);
|
|
const migratedSnapshotIds = new Set(
|
|
migratedSnapshots.map((conversation) => conversation.id),
|
|
);
|
|
for (const conversation of nextConversations) {
|
|
if (migratedSnapshotIds.has(conversation.id)) {
|
|
acknowledgedLocalConversations.set(conversation.id, conversation);
|
|
}
|
|
}
|
|
}
|
|
while (true) {
|
|
const migration = createLocalConversationSaveBatch(
|
|
nextConversations,
|
|
acknowledgedLocalConversations,
|
|
new Set(),
|
|
);
|
|
if (migration.batch.length === 0) {
|
|
break;
|
|
}
|
|
await window.goodbuddy.conversations.saveLocal(migration.batch);
|
|
for (const conversation of migration.acknowledgements) {
|
|
acknowledgedLocalConversations.set(conversation.id, conversation);
|
|
}
|
|
}
|
|
}
|
|
if (!active) {
|
|
return;
|
|
}
|
|
conversationPersistence.replaceAcknowledged(acknowledgedLocalConversations);
|
|
setConversations(nextConversations);
|
|
setActiveId(projectConversation?.id ?? "");
|
|
try {
|
|
localStorage.removeItem(storageKey);
|
|
conversationMigrationStoragePresent.current = false;
|
|
} catch {
|
|
// The SQLite migration has already completed successfully.
|
|
}
|
|
setConversationStoreReady(true);
|
|
});
|
|
conversationPersistence.chain(initialization);
|
|
void initialization.catch((reason: unknown) => {
|
|
if (active) {
|
|
setConversationLoadError(
|
|
displayErrorMessage(
|
|
reason,
|
|
tRef.current("notices.projectReadFailed"),
|
|
),
|
|
);
|
|
}
|
|
});
|
|
return () => {
|
|
active = false;
|
|
};
|
|
}, [conversationLoadRetry, setActiveId, setConversations, conversationPersistence]);
|
|
|
|
useEffect(() => {
|
|
if (!activeProjectId) {
|
|
return;
|
|
}
|
|
void window.goodbuddy.memory
|
|
.list(activeProjectId)
|
|
.then(setAssistantMemories)
|
|
.catch(() =>
|
|
notify({
|
|
tone: "error",
|
|
message: tRef.current("notices.memoryReadFailed"),
|
|
}),
|
|
);
|
|
}, [activeProjectId]);
|
|
|
|
const refreshWorkspaceChanges = useCallback(async (): Promise<void> => {
|
|
if (!activeProjectId) {
|
|
workspaceChangesRequestRef.current += 1;
|
|
setWorkspaceChanges(undefined);
|
|
return;
|
|
}
|
|
await loadWorkspaceChanges(activeProjectId);
|
|
}, [activeProjectId, loadWorkspaceChanges]);
|
|
|
|
const listWorkspaceDirectory = useCallback(
|
|
async (path: string) => {
|
|
if (!activeProjectId) {
|
|
throw new Error(tRef.current("notices.selectProject"));
|
|
}
|
|
return window.goodbuddy.workspace.listDirectory(activeProjectId, path);
|
|
},
|
|
[activeProjectId],
|
|
);
|
|
|
|
const loadWorkspaceFile = useCallback(
|
|
async (path: string, offsetBytes = 0) => {
|
|
if (!activeProjectId) {
|
|
throw new Error(tRef.current("notices.selectProject"));
|
|
}
|
|
return window.goodbuddy.workspace.readFile(
|
|
activeProjectId,
|
|
path,
|
|
offsetBytes,
|
|
);
|
|
},
|
|
[activeProjectId],
|
|
);
|
|
const loadWorkspaceDiff = useCallback(
|
|
async (path: string) => {
|
|
if (!activeProjectId)
|
|
throw new Error(tRef.current("notices.selectProject"));
|
|
return window.goodbuddy.workspace.getFileDiff(activeProjectId, path);
|
|
},
|
|
[activeProjectId],
|
|
);
|
|
const openWorkspaceEntry = useCallback(
|
|
async (path: string, type: "file" | "directory"): Promise<void> => {
|
|
if (!activeProjectId) {
|
|
throw new Error(tRef.current("notices.selectProject"));
|
|
}
|
|
await window.goodbuddy.workspace.openPath(activeProjectId, path, type);
|
|
},
|
|
[activeProjectId],
|
|
);
|
|
|
|
useEffect(() => {
|
|
const timeout = setTimeout(() => {
|
|
void refreshWorkspaceChanges().catch(() => {
|
|
notify({
|
|
tone: "error",
|
|
message: tRef.current("notices.workspaceChangesReadFailed"),
|
|
});
|
|
});
|
|
}, 0);
|
|
return () => clearTimeout(timeout);
|
|
}, [refreshWorkspaceChanges]);
|
|
|
|
useEffect(() => {
|
|
void window.goodbuddy.experts
|
|
.list()
|
|
.then(setAssistantExperts)
|
|
.catch(() =>
|
|
notify({
|
|
tone: "error",
|
|
message: tRef.current("notices.expertsReadFailed"),
|
|
}),
|
|
);
|
|
}, []);
|
|
|
|
useEffect(() => {
|
|
if (!activeProjectId) {
|
|
return;
|
|
}
|
|
void window.goodbuddy.schedules
|
|
.list()
|
|
.then(setAssistantSchedules)
|
|
.catch(() =>
|
|
notify({
|
|
tone: "error",
|
|
message: tRef.current("notices.schedulesReadFailed"),
|
|
}),
|
|
);
|
|
}, [activeProjectId]);
|
|
|
|
const loadHeartbeats = useCallback(async () => {
|
|
const [configs, memories] = await Promise.all([
|
|
window.goodbuddy.heartbeats.list(),
|
|
window.goodbuddy.memory.list(),
|
|
]);
|
|
const history = await window.goodbuddy.heartbeats.history();
|
|
// Main returns no suggestions while the supervisor is disabled.
|
|
const suggestions = await window.goodbuddy.supervision?.suggestions?.({ status: "pending", limit: 100 })
|
|
.catch(() => []) ?? [];
|
|
return {
|
|
configs,
|
|
memories,
|
|
runs: history.runs,
|
|
entries: history.entries,
|
|
pendingSuggestions: suggestions.length,
|
|
};
|
|
}, []);
|
|
|
|
const refreshHeartbeats = useCallback(async (): Promise<void> => {
|
|
const requestId = ++heartbeatLoadRequestRef.current;
|
|
const result = await loadHeartbeats();
|
|
if (requestId !== heartbeatLoadRequestRef.current) {
|
|
return;
|
|
}
|
|
setAssistantHeartbeats(result.configs);
|
|
setHeartbeatMemories(result.memories);
|
|
setHeartbeatRuns(result.runs);
|
|
setHeartbeatEntries(result.entries);
|
|
setPendingHeartbeatSuggestionCount(result.pendingSuggestions);
|
|
}, [loadHeartbeats]);
|
|
|
|
useEffect(() => {
|
|
if (projects.length === 0) {
|
|
return;
|
|
}
|
|
const requestId = ++heartbeatLoadRequestRef.current;
|
|
const timeout = setTimeout(() => {
|
|
if (requestId !== heartbeatLoadRequestRef.current) {
|
|
return;
|
|
}
|
|
setHeartbeatLoading(true);
|
|
setHeartbeatLoadError(undefined);
|
|
setAssistantHeartbeats([]);
|
|
setHeartbeatRuns([]);
|
|
setHeartbeatEntries([]);
|
|
void loadHeartbeats()
|
|
.then((result) => {
|
|
if (requestId !== heartbeatLoadRequestRef.current) {
|
|
return;
|
|
}
|
|
setAssistantHeartbeats(result.configs);
|
|
setHeartbeatMemories(result.memories);
|
|
setHeartbeatRuns(result.runs);
|
|
setHeartbeatEntries(result.entries);
|
|
setPendingHeartbeatSuggestionCount(result.pendingSuggestions);
|
|
setHeartbeatLoadError(undefined);
|
|
})
|
|
.catch((reason: unknown) => {
|
|
if (requestId !== heartbeatLoadRequestRef.current) {
|
|
return;
|
|
}
|
|
setHeartbeatLoadError(
|
|
displayErrorMessage(
|
|
reason,
|
|
tRef.current("notices.heartbeatReadFailed"),
|
|
),
|
|
);
|
|
})
|
|
.finally(() => {
|
|
if (requestId === heartbeatLoadRequestRef.current) {
|
|
setHeartbeatLoading(false);
|
|
}
|
|
});
|
|
}, 0);
|
|
return () => {
|
|
clearTimeout(timeout);
|
|
if (requestId === heartbeatLoadRequestRef.current) {
|
|
heartbeatLoadRequestRef.current += 1;
|
|
}
|
|
};
|
|
}, [loadHeartbeats, projects.length]);
|
|
|
|
const refreshHeartbeatCenter = useCallback(async (): Promise<void> => {
|
|
await refreshHeartbeats();
|
|
}, [refreshHeartbeats]);
|
|
|
|
const retryHeartbeatLoad = useCallback(async (): Promise<void> => {
|
|
setHeartbeatLoading(true);
|
|
setHeartbeatLoadError(undefined);
|
|
try {
|
|
await refreshHeartbeatCenter();
|
|
setHeartbeatLoadError(undefined);
|
|
} catch (reason) {
|
|
setHeartbeatLoadError(
|
|
displayErrorMessage(
|
|
reason,
|
|
tRef.current("notices.heartbeatReadFailed"),
|
|
),
|
|
);
|
|
} finally {
|
|
setHeartbeatLoading(false);
|
|
}
|
|
}, [refreshHeartbeatCenter]);
|
|
|
|
const createHeartbeat = useCallback(
|
|
async (input: HeartbeatCreateInput): Promise<void> => {
|
|
await window.goodbuddy.heartbeats.create(input);
|
|
await refreshHeartbeats();
|
|
},
|
|
[refreshHeartbeats],
|
|
);
|
|
|
|
const updateHeartbeat = useCallback(
|
|
async (heartbeatId: string, input: HeartbeatUpdateInput): Promise<void> => {
|
|
await window.goodbuddy.heartbeats.update(heartbeatId, input);
|
|
await refreshHeartbeats();
|
|
},
|
|
[refreshHeartbeats],
|
|
);
|
|
|
|
const removeHeartbeat = useCallback(
|
|
async (heartbeatId: string): Promise<void> => {
|
|
await window.goodbuddy.heartbeats.remove(heartbeatId);
|
|
await refreshHeartbeats();
|
|
},
|
|
[refreshHeartbeats],
|
|
);
|
|
|
|
const runHeartbeat = useCallback(
|
|
async (heartbeatId: string): Promise<void> => {
|
|
await window.goodbuddy.heartbeats.runNow(heartbeatId);
|
|
await refreshHeartbeatCenter();
|
|
},
|
|
[refreshHeartbeatCenter],
|
|
);
|
|
|
|
const setHeartbeatPaused = useCallback(
|
|
async (heartbeatId: string, paused: boolean): Promise<void> => {
|
|
await window.goodbuddy.heartbeats.setPaused(heartbeatId, paused);
|
|
await refreshHeartbeats();
|
|
},
|
|
[refreshHeartbeats],
|
|
);
|
|
|
|
useEffect(() => {
|
|
if (view !== "heartbeat") {
|
|
return;
|
|
}
|
|
let refreshing = false;
|
|
const refresh = (): void => {
|
|
if (refreshing) {
|
|
return;
|
|
}
|
|
refreshing = true;
|
|
void refreshHeartbeatCenter()
|
|
.then(() => setHeartbeatLoadError(undefined))
|
|
.catch((reason: unknown) =>
|
|
setHeartbeatLoadError(
|
|
displayErrorMessage(
|
|
reason,
|
|
tRef.current("notices.heartbeatRefreshFailed"),
|
|
),
|
|
),
|
|
)
|
|
.finally(() => {
|
|
refreshing = false;
|
|
});
|
|
};
|
|
const timeout = setTimeout(refresh, 0);
|
|
const interval = setInterval(refresh, 30_000);
|
|
return () => {
|
|
clearTimeout(timeout);
|
|
clearInterval(interval);
|
|
};
|
|
}, [refreshHeartbeatCenter, view]);
|
|
|
|
useEffect(() => {
|
|
void window.goodbuddy.tasks
|
|
.list()
|
|
.then((tasks) => {
|
|
setAssistantTasks(tasks);
|
|
activityStore.reconcile(tasks, new Set(activeRuns.current.keys()));
|
|
})
|
|
.catch(() =>
|
|
notify({
|
|
tone: "error",
|
|
message: tRef.current("notices.taskHistoryReadFailed"),
|
|
}),
|
|
);
|
|
}, [activityStore, setAssistantTasks]);
|
|
|
|
useEffect(() => {
|
|
if (view !== "activity") {
|
|
return;
|
|
}
|
|
const timeout = setTimeout(() => {
|
|
void refreshTokenUsage().catch(() =>
|
|
notify({
|
|
tone: "error",
|
|
message: tRef.current("notices.tokenUsageReadFailed"),
|
|
}),
|
|
);
|
|
}, 0);
|
|
// Usage is polled while the page is visible instead of following every
|
|
// usage change, so background and streaming work stay off this page.
|
|
const interval = window.setInterval(() => {
|
|
void refreshTokenUsage().catch(() => undefined);
|
|
}, activityPanelRefreshIntervalMs);
|
|
return () => {
|
|
clearTimeout(timeout);
|
|
window.clearInterval(interval);
|
|
};
|
|
}, [refreshTokenUsage, view]);
|
|
|
|
const manualRefreshActivity = useCallback(async (): Promise<void> => {
|
|
await showActivity();
|
|
try {
|
|
await refreshTokenUsage();
|
|
} catch {
|
|
notify({
|
|
tone: "error",
|
|
message: tRef.current("notices.tokenUsageReadFailed"),
|
|
});
|
|
}
|
|
}, [notify, showActivity, refreshTokenUsage]);
|
|
const { loadMore: loadMoreActivity, setFilter: setActivityFilter } = activitySync;
|
|
const activityPaging = useMemo(() => ({
|
|
filter: activityPanel.page.filter, summary: activityPanel.summary, hasMore: activityPanel.page.hasMore,
|
|
onFilterChange: (filter: ActivityHistoryFilter) => void setActivityFilter(filter),
|
|
onLoadMore: () => void loadMoreActivity(),
|
|
}), [activityPanel, loadMoreActivity, setActivityFilter]);
|
|
|
|
useInitialArtifactSync(taskStore, () =>
|
|
notify({
|
|
tone: "error",
|
|
message: tRef.current("notices.resultHistoryReadFailed"),
|
|
}),
|
|
);
|
|
|
|
useArtifactHydration(taskStore, activeConversation?.artifactIds, hydratingArtifactIds);
|
|
|
|
useEffect(() => {
|
|
const timeout = setTimeout(() => {
|
|
void refreshKnowledge()
|
|
.catch(() => {
|
|
// refreshKnowledge exposes a recoverable page-local error.
|
|
})
|
|
.finally(() => setKnowledgeLoading(false));
|
|
}, 0);
|
|
return () => clearTimeout(timeout);
|
|
}, [refreshKnowledge]);
|
|
|
|
useEffect(() => {
|
|
if (
|
|
knowledgeLoadError ||
|
|
(view !== "knowledge" && knowledgeOperationCount === 0)
|
|
) {
|
|
return;
|
|
}
|
|
const interval = setInterval(
|
|
() => {
|
|
void refreshKnowledge(knowledgeSnapshot.selectedLibraryId).catch(() => {
|
|
// The task center keeps the last successful snapshot while polling.
|
|
});
|
|
},
|
|
knowledgeOperationCount > 0 ? 350 : 1_000,
|
|
);
|
|
return () => clearInterval(interval);
|
|
}, [
|
|
knowledgeLoadError,
|
|
knowledgeOperationCount,
|
|
knowledgeSnapshot.selectedLibraryId,
|
|
refreshKnowledge,
|
|
view,
|
|
]);
|
|
|
|
useEffect(() => {
|
|
void Promise.all([
|
|
window.goodbuddy.settings.getRuntime(),
|
|
window.goodbuddy.agent.getStatus(),
|
|
])
|
|
.then(([settings, status]) => {
|
|
const selectionKey = agentRuntimeSelectionKey(
|
|
resolveRuntimeChoice(settings).selection,
|
|
);
|
|
runtimeStatusCacheRef.current = {
|
|
key: selectionKey,
|
|
settings,
|
|
};
|
|
setRuntimeSettings(settings);
|
|
setRuntime(status);
|
|
setRuntimeStatusKey(selectionKey);
|
|
if (!status.available && !runtimeSetupPromptedRef.current) {
|
|
runtimeSetupPromptedRef.current = true;
|
|
setView("settings");
|
|
}
|
|
})
|
|
.catch(() =>
|
|
notify({
|
|
tone: "error",
|
|
message: tRef.current("runtime.errors.readSettings"),
|
|
}),
|
|
);
|
|
void window.goodbuddy.app
|
|
.getInfo()
|
|
.then(setAppInfo)
|
|
.catch(() =>
|
|
notify({
|
|
tone: "error",
|
|
message: tRef.current("notices.appInfoReadFailed"),
|
|
}),
|
|
);
|
|
const removeAgentListener =
|
|
window.goodbuddy.agent.onEvent(handleAgentEvent);
|
|
const removeImageListener = window.goodbuddy.conversations.imageOperations.onChanged((operation) => {
|
|
setConversations(current => current.map(conversation => conversation.id !== operation.conversationId ? conversation : {
|
|
...conversation,
|
|
updatedAt: Math.max(conversation.updatedAt, operation.updatedAt),
|
|
messages: conversation.messages.map(message => message.id !== operation.messageId ? message : {
|
|
...message,
|
|
imageOperations: message.imageOperations?.some(item => item.id === operation.id)
|
|
? message.imageOperations.map(item => item.id === operation.id ? operation : item)
|
|
: [...(message.imageOperations ?? []), operation],
|
|
artifactIds: [...new Set([...(message.artifactIds ?? []), ...operation.artifactIds])].slice(-8),
|
|
}),
|
|
}));
|
|
});
|
|
const removeOpenSettingsListener = window.goodbuddy.app.onOpenSettings((category) => {
|
|
setSettingsInitialCategory(category ?? "runtime");
|
|
setView("settings");
|
|
});
|
|
return () => {
|
|
removeAgentListener();
|
|
removeImageListener();
|
|
removeOpenSettingsListener();
|
|
};
|
|
}, [handleAgentEvent, setView, setConversations]);
|
|
|
|
useEffect(() => {
|
|
const browserApi = window.goodbuddy.browser;
|
|
if (!browserApi) {
|
|
return;
|
|
}
|
|
return browserApi.onState((state) => {
|
|
const tabId = state.tabId;
|
|
setBrowserStates((current) => {
|
|
const conversationStates = current[state.conversationId] ?? {};
|
|
if (state.status === "stopped") {
|
|
if (!(tabId in conversationStates)) {
|
|
return current;
|
|
}
|
|
const nextConversationStates = { ...conversationStates };
|
|
delete nextConversationStates[tabId];
|
|
const next = { ...current };
|
|
if (Object.keys(nextConversationStates).length === 0) {
|
|
delete next[state.conversationId];
|
|
} else {
|
|
next[state.conversationId] = nextConversationStates;
|
|
}
|
|
return next;
|
|
}
|
|
return {
|
|
...current,
|
|
[state.conversationId]: {
|
|
...conversationStates,
|
|
[tabId]: state,
|
|
},
|
|
};
|
|
});
|
|
if (
|
|
state.status !== "stopped" &&
|
|
state.conversationId === conversationNavigationRef.current.activeId
|
|
) {
|
|
setAssistantSidebarOpen(true);
|
|
setAssistantSidebarTab("browser");
|
|
}
|
|
});
|
|
}, []);
|
|
|
|
useEffect(
|
|
() =>
|
|
window.goodbuddy.app.onNewConversation(() => {
|
|
startNewConversation(activeProjectIdRef.current || undefined);
|
|
}),
|
|
[startNewConversation],
|
|
);
|
|
|
|
useEffect(() => {
|
|
const handleNewConversationShortcut = (event: KeyboardEvent): void => {
|
|
if (
|
|
event.key.toLocaleLowerCase() !== "n" ||
|
|
(!event.ctrlKey && !event.metaKey) ||
|
|
event.altKey ||
|
|
event.shiftKey
|
|
) {
|
|
return;
|
|
}
|
|
event.preventDefault();
|
|
startNewConversation(activeProjectIdRef.current || undefined);
|
|
};
|
|
document.addEventListener("keydown", handleNewConversationShortcut);
|
|
return () =>
|
|
document.removeEventListener("keydown", handleNewConversationShortcut);
|
|
}, [startNewConversation]);
|
|
|
|
const commitProjectSelection = (
|
|
selected: AssistantProject,
|
|
candidateConversations = conversationStore.getState(),
|
|
): void => {
|
|
setActiveProjectId(selected.id);
|
|
const conversation = conversationStore.projectConversation(selected.id, selected.kind === "channel", candidateConversations);
|
|
if (conversation) {
|
|
// Remote projects ignore incompatible conversation choices at resolution time
|
|
// and say so in the picker, instead of silently rewriting saved conversations.
|
|
setActiveId(conversation.id);
|
|
} else if (selected.kind === "channel") {
|
|
setActiveId("");
|
|
} else {
|
|
const created = createConversation(
|
|
selected.id,
|
|
undefined,
|
|
t("conversation.greeting"),
|
|
);
|
|
setConversations((current) => [created, ...current]);
|
|
setActiveId(created.id);
|
|
}
|
|
commitView("chat");
|
|
};
|
|
|
|
const selectProject = (projectId: string): void => {
|
|
const project = projects.find((candidate) => candidate.id === projectId);
|
|
if (!project) {
|
|
return;
|
|
}
|
|
if (project.executionSpace.kind === "ssh" && !remoteProjectsEnabled) {
|
|
return;
|
|
}
|
|
commitProjectSelection(project);
|
|
if (
|
|
!isProjectRecoveryUnsettled(
|
|
projectRecoveryByProjectIdRef.current[project.id],
|
|
)
|
|
) {
|
|
resumeProjectConversationQueues(project.id);
|
|
}
|
|
};
|
|
|
|
const createProject = async (
|
|
input: ProjectCreateInput,
|
|
): Promise<AssistantProject> => {
|
|
const project = await window.goodbuddy.projects.create(input);
|
|
setProjects((current) => [project, ...current]);
|
|
requestWorkspaceLeave("chat", () => commitProjectSelection(project));
|
|
return project;
|
|
};
|
|
|
|
const updateProject = async (
|
|
projectId: string,
|
|
input: ProjectCreateInput,
|
|
): Promise<AssistantProject> => {
|
|
const project = await window.goodbuddy.projects.update(projectId, input);
|
|
setProjects((current) =>
|
|
current.map((candidate) =>
|
|
candidate.id === project.id ? project : candidate,
|
|
),
|
|
);
|
|
return project;
|
|
};
|
|
|
|
const loadCommittedRemoteProject = async (
|
|
project: AssistantProject,
|
|
): Promise<void> => {
|
|
if (!remoteProjectsEnabled || project.executionSpace.kind !== "ssh") {
|
|
return;
|
|
}
|
|
setProjects((current) =>
|
|
current.some((candidate) => candidate.id === project.id)
|
|
? current.map((candidate) =>
|
|
candidate.id === project.id ? project : candidate,
|
|
)
|
|
: [project, ...current],
|
|
);
|
|
requestWorkspaceLeave("chat", () => commitProjectSelection(project));
|
|
if (
|
|
!isProjectRecoveryUnsettled(
|
|
projectRecoveryByProjectIdRef.current[project.id],
|
|
)
|
|
) {
|
|
resumeProjectConversationQueues(project.id);
|
|
}
|
|
};
|
|
|
|
const handleRemoteProjectsEnabledChange = (enabled: boolean): void => {
|
|
setRemoteProjectsEnabled(enabled);
|
|
if (enabled) {
|
|
return;
|
|
}
|
|
if (activeProject?.executionSpace.kind !== "ssh") {
|
|
return;
|
|
}
|
|
const localProject = projects.find(isOrdinaryLocalProject);
|
|
if (localProject) {
|
|
commitProjectSelection(localProject);
|
|
}
|
|
};
|
|
|
|
const archiveProject = async (projectId: string): Promise<void> => {
|
|
await window.goodbuddy.projects.setArchived(projectId, true);
|
|
const remaining = projects.filter((project) => project.id !== projectId);
|
|
setProjects(remaining);
|
|
if (projectId === activeProjectIdRef.current) {
|
|
const next =
|
|
remaining.find(isOrdinaryLocalProject) ??
|
|
(remoteProjectsEnabled ? remaining[0] : undefined);
|
|
if (next) {
|
|
selectProject(next.id);
|
|
}
|
|
}
|
|
};
|
|
|
|
const removeProjectsFromUi = (projectIds: readonly string[]): void => {
|
|
if (projectIds.length === 0) {
|
|
return;
|
|
}
|
|
const deletedProjectIds = new Set(projectIds);
|
|
const referencesDeletedProject = (projectId: string | undefined): boolean =>
|
|
projectId !== undefined && deletedProjectIds.has(projectId);
|
|
const remainingProjects = projectsRef.current.filter(
|
|
(project) => !deletedProjectIds.has(project.id),
|
|
);
|
|
const currentConversations = conversationStore.getState();
|
|
const deletedConversationIds = new Set(
|
|
currentConversations
|
|
.filter((conversation) =>
|
|
referencesDeletedProject(conversation.projectId),
|
|
)
|
|
.map((conversation) => conversation.id),
|
|
);
|
|
const remainingConversations = currentConversations.filter(
|
|
(conversation) => !referencesDeletedProject(conversation.projectId),
|
|
);
|
|
setProjects((current) =>
|
|
current.filter((project) => !deletedProjectIds.has(project.id)),
|
|
);
|
|
setConversations((current) =>
|
|
current.filter(
|
|
(conversation) => !referencesDeletedProject(conversation.projectId),
|
|
),
|
|
);
|
|
setAssistantTasks((current) =>
|
|
current.filter((task) => !referencesDeletedProject(task.projectId)),
|
|
);
|
|
setAssistantArtifacts((current) =>
|
|
current.filter(
|
|
(artifact) => !referencesDeletedProject(artifact.projectId),
|
|
),
|
|
);
|
|
setAssistantMemories((current) =>
|
|
current.filter(
|
|
(memory) =>
|
|
!(
|
|
memory.scope === "project" &&
|
|
referencesDeletedProject(memory.scopeId)
|
|
) &&
|
|
!(
|
|
memory.scope === "conversation" &&
|
|
memory.scopeId !== undefined &&
|
|
deletedConversationIds.has(memory.scopeId)
|
|
),
|
|
),
|
|
);
|
|
setAssistantSchedules((current) =>
|
|
current.filter(
|
|
(schedule) => !referencesDeletedProject(schedule.projectId),
|
|
),
|
|
);
|
|
setAssistantHeartbeats((current) =>
|
|
current.flatMap((heartbeat) => {
|
|
if (heartbeat.scope.kind === "global") {
|
|
return heartbeat;
|
|
}
|
|
const projectIds = heartbeat.scope.projectIds.filter(
|
|
(id) => !deletedProjectIds.has(id),
|
|
);
|
|
return projectIds.length > 0
|
|
? [{ ...heartbeat, scope: { kind: "projects", projectIds } }]
|
|
: [];
|
|
}),
|
|
);
|
|
if (!deletedProjectIds.has(activeProjectIdRef.current)) {
|
|
return;
|
|
}
|
|
const next = remainingProjects.find(isOrdinaryLocalProject);
|
|
if (next) {
|
|
commitProjectSelection(next, remainingConversations);
|
|
return;
|
|
}
|
|
setActiveProjectId("");
|
|
setActiveId("");
|
|
setView("chat");
|
|
};
|
|
|
|
const deleteProject = async (
|
|
projectId: string,
|
|
confirmation: string,
|
|
): Promise<void> => {
|
|
await window.goodbuddy.projects.delete(projectId, confirmation);
|
|
removeProjectsFromUi([projectId]);
|
|
};
|
|
|
|
const newConversation = (): boolean => {
|
|
return startNewConversation(activeProjectId || undefined);
|
|
};
|
|
|
|
const setMemoryStatus = async (
|
|
memoryId: string,
|
|
status: AssistantMemory["status"],
|
|
): Promise<void> => {
|
|
await window.goodbuddy.memory.setStatus(memoryId, status);
|
|
setAssistantMemories((current) =>
|
|
status === "rejected"
|
|
? current.filter((memory) => memory.id !== memoryId)
|
|
: current.map((memory) =>
|
|
memory.id === memoryId ? { ...memory, status } : memory,
|
|
),
|
|
);
|
|
setHeartbeatMemories((current) =>
|
|
status === "rejected"
|
|
? current.filter((memory) => memory.id !== memoryId)
|
|
: current.map((memory) =>
|
|
memory.id === memoryId ? { ...memory, status } : memory,
|
|
),
|
|
);
|
|
};
|
|
|
|
const useHeartbeatTask = (task: AssistantTask): void => {
|
|
if (task.projectId && task.projectId !== activeProjectId) {
|
|
setActiveProjectId(task.projectId);
|
|
}
|
|
if (
|
|
!startNewConversation(task.projectId ?? (activeProjectId || undefined))
|
|
) {
|
|
return;
|
|
}
|
|
setInput(
|
|
[t("notices.heartbeatTaskPrompt"), task.title, task.instructions].join(
|
|
"\n\n",
|
|
),
|
|
);
|
|
notify({
|
|
tone: "info",
|
|
message: t("notices.heartbeatTaskAdded", { title: task.title }),
|
|
});
|
|
requestAnimationFrame(() => inputRef.current?.focus());
|
|
};
|
|
|
|
const setHeartbeatTaskStatus = async (
|
|
taskId: string,
|
|
status: "completed" | "cancelled",
|
|
): Promise<void> => {
|
|
await window.goodbuddy.tasks.setStatus(taskId, status);
|
|
setAssistantTasks((current) =>
|
|
current.map((task) =>
|
|
task.id === taskId
|
|
? {
|
|
...task,
|
|
status,
|
|
completedAt: new Date().toISOString(),
|
|
}
|
|
: task,
|
|
),
|
|
);
|
|
};
|
|
|
|
const setConversationPinned = async (conversation: Conversation): Promise<void> => {
|
|
if (conversationPinPendingRef.current || !conversationStoreReady) return;
|
|
conversationPinPendingRef.current = true;
|
|
conversationPinRevisionRef.current += 1;
|
|
setPinningConversationId(conversation.id);
|
|
try {
|
|
if (!conversation.remote) {
|
|
await conversationPersistence.idle();
|
|
if (!conversationPersistence.acknowledged().has(conversation.id)) {
|
|
const draft = conversationStore.getState().find(item => item.id === conversation.id);
|
|
if (!draft) return;
|
|
await window.goodbuddy.conversations.saveLocal([{
|
|
header: toLocalConversationHeader(draft),
|
|
messages: draft.messages.map(toConversationMessage),
|
|
}]);
|
|
conversationPersistence.acknowledged().set(draft.id, draft);
|
|
}
|
|
}
|
|
const pinned = !conversation.pinned;
|
|
await window.goodbuddy.conversations.setPinned({ conversationId: conversation.id, pinned });
|
|
const next = conversationStore.getState().map(item => item.id === conversation.id ? { ...item, pinned } : item);
|
|
setConversations(next);
|
|
} catch {
|
|
notify({ tone: "error", message: t("notices.conversationPinFailed") });
|
|
} finally {
|
|
conversationPinPendingRef.current = false;
|
|
conversationPinRevisionRef.current += 1;
|
|
setPinningConversationId("");
|
|
}
|
|
};
|
|
|
|
const deleteConversation = async (conversationId: string): Promise<void> => {
|
|
if (deletingConversationId) {
|
|
return;
|
|
}
|
|
setDeletingConversationId(conversationId);
|
|
const activeRequests = [...activeRuns.current.entries()]
|
|
.filter(([, run]) => run.conversationId === conversationId)
|
|
.map(([requestId]) => requestId);
|
|
try {
|
|
await Promise.all(
|
|
activeRequests.map((requestId) =>
|
|
window.goodbuddy.agent.cancel(requestId),
|
|
),
|
|
);
|
|
} catch {
|
|
notify({
|
|
tone: "error",
|
|
message: t("notices.deleteConversationCancelFailed"),
|
|
});
|
|
setDeletingConversationId("");
|
|
return;
|
|
}
|
|
const deletingConversation = conversationStore.getState().find(
|
|
(conversation) => conversation.id === conversationId,
|
|
);
|
|
if (deletingConversation && !deletingConversation.remote) {
|
|
conversationPersistence.markDeleting(conversationId, true);
|
|
try {
|
|
await conversationPersistence.idle();
|
|
await attachmentSaveQueue.current;
|
|
await window.goodbuddy.conversations.deleteLocal(conversationId);
|
|
conversationPersistence.acknowledged().delete(conversationId);
|
|
} catch {
|
|
conversationPersistence.markDeleting(conversationId, false);
|
|
notify({
|
|
tone: "error",
|
|
message: t("notices.deleteConversationPersistenceFailed"),
|
|
});
|
|
setDeletingConversationId("");
|
|
return;
|
|
}
|
|
}
|
|
setConfirmingConversationId("");
|
|
setDeletingConversationId("");
|
|
if (conversationActionsId === conversationId) {
|
|
setConversationActionsId("");
|
|
}
|
|
if (renamingConversationId === conversationId) {
|
|
setRenamingConversationId("");
|
|
}
|
|
const browserStop = window.goodbuddy.browser?.stop(conversationId);
|
|
if (browserStop) {
|
|
void browserStop.catch(() => {
|
|
notify({
|
|
tone: "error",
|
|
message: t("notices.deletedConversationBrowserCloseFailed"),
|
|
});
|
|
});
|
|
}
|
|
setBrowserStates((current) => {
|
|
const next = { ...current };
|
|
delete next[conversationId];
|
|
return next;
|
|
});
|
|
const draftAttachments = attachmentsRef.current.get(conversationId) ?? [];
|
|
attachmentsRef.current.delete(conversationId);
|
|
for (const attachment of draftAttachments) {
|
|
void window.goodbuddy.context.remove(attachment.id);
|
|
}
|
|
setAttachmentsByConversation((current) => {
|
|
const next = { ...current };
|
|
delete next[conversationId];
|
|
return next;
|
|
});
|
|
composerDrafts.delete(conversationId);
|
|
setChatScrollSnapshots((current) => {
|
|
const next = { ...current };
|
|
delete next[conversationId];
|
|
return next;
|
|
});
|
|
setVisibleMessageCounts((current) => {
|
|
const next = { ...current };
|
|
delete next[conversationId];
|
|
return next;
|
|
});
|
|
setConversationActivity(conversationId, false);
|
|
const remaining = conversationStore.getState().filter(
|
|
(conversation) => conversation.id !== conversationId,
|
|
);
|
|
conversationPersistence.markDeleting(conversationId, false);
|
|
const projectRemaining = remaining.filter(
|
|
(conversation) => conversation.projectId === activeProjectId,
|
|
);
|
|
setConversations(remaining);
|
|
if (projectRemaining.length > 0) {
|
|
if (conversationId === activeId) {
|
|
setActiveId(projectRemaining[0]?.id ?? "");
|
|
}
|
|
return;
|
|
}
|
|
if (activeProject?.kind === "channel") {
|
|
setActiveId("");
|
|
return;
|
|
}
|
|
const replacement = createConversation(
|
|
activeProjectId || undefined,
|
|
undefined,
|
|
t("conversation.greeting"),
|
|
);
|
|
setConversations((current) => [replacement, ...current]);
|
|
setActiveId(replacement.id);
|
|
};
|
|
|
|
const branchConversation = async (
|
|
sourceConversation: Conversation,
|
|
): Promise<void> => {
|
|
if (
|
|
branchingConversationId ||
|
|
sourceConversation.remote ||
|
|
!conversationStoreReady ||
|
|
activeConversationIds.has(sourceConversation.id) ||
|
|
queuedConversationIds.has(sourceConversation.id)
|
|
) {
|
|
return;
|
|
}
|
|
setBranchingConversationId(sourceConversation.id);
|
|
try {
|
|
persistLocalConversationChanges();
|
|
await conversationPersistence.idle();
|
|
if (
|
|
conversationPersistence.acknowledged().get(sourceConversation.id) !==
|
|
sourceConversation ||
|
|
conversationStore.getState().find(
|
|
(conversation) => conversation.id === sourceConversation.id,
|
|
) !== sourceConversation
|
|
) {
|
|
throw new Error(t("notices.conversationPersistenceFailed"));
|
|
}
|
|
const sourceTitle = getConversationDisplayTitle(
|
|
sourceConversation,
|
|
t("conversation.defaultTitle"),
|
|
);
|
|
const branch = await window.goodbuddy.conversations.branchLocal({
|
|
sourceConversationId: sourceConversation.id,
|
|
title: createConversationBranchTitle(
|
|
sourceTitle,
|
|
t("conversation.branch.suffix"),
|
|
),
|
|
});
|
|
const nextBranch: Conversation = branch;
|
|
conversationPersistence.acknowledged().set(nextBranch.id, nextBranch);
|
|
setConversations((current) => [
|
|
nextBranch,
|
|
...current.filter((conversation) => conversation.id !== nextBranch.id),
|
|
]);
|
|
setSelectedAssistantTaskId(undefined);
|
|
setActiveId(nextBranch.id);
|
|
showChatAndFocusComposer();
|
|
if (narrowWindow) {
|
|
closeNarrowSidebar();
|
|
}
|
|
notify({
|
|
tone: "success",
|
|
message: t("notices.conversationBranched"),
|
|
});
|
|
} catch (error) {
|
|
notify({
|
|
tone: "error",
|
|
message: displayErrorMessage(
|
|
error,
|
|
t("notices.conversationBranchFailed"),
|
|
),
|
|
});
|
|
focusConversationActions(sourceConversation.id);
|
|
} finally {
|
|
setBranchingConversationId("");
|
|
}
|
|
};
|
|
|
|
const focusConversationActions = (conversationId: string): void => {
|
|
requestAnimationFrame(() =>
|
|
conversationActionTriggerRefs.current.get(conversationId)?.focus(),
|
|
);
|
|
};
|
|
|
|
const saveTitle = (conversationId: string, titleInput: string): void => {
|
|
const title = titleInput.trim().slice(0, 80);
|
|
if (!title) {
|
|
return;
|
|
}
|
|
setConversations((current) =>
|
|
current.map((conversation) =>
|
|
conversation.id === conversationId
|
|
? { ...conversation, title, updatedAt: Date.now() }
|
|
: conversation,
|
|
),
|
|
);
|
|
setRenamingConversationId("");
|
|
focusConversationActions(conversationId);
|
|
};
|
|
|
|
const writeClipboardText = useCallback(
|
|
async (content: string, successMessage?: string): Promise<boolean> => {
|
|
try {
|
|
await window.goodbuddy.clipboard.writeText(content);
|
|
if (successMessage) notify({
|
|
tone: "success",
|
|
message: successMessage,
|
|
});
|
|
return true;
|
|
} catch {
|
|
notify({
|
|
tone: "error",
|
|
message: t("notices.clipboardUnavailable"),
|
|
});
|
|
return false;
|
|
}
|
|
},
|
|
[t],
|
|
);
|
|
|
|
const readConversationForExport = async (selected: Conversation): Promise<Conversation> => {
|
|
// Streaming deltas reach the conversation store only on the live-message
|
|
// flush cadence; absorb them now so the copy holds everything on screen.
|
|
if (liveMessages.hasEntries()) setConversations((current) => current);
|
|
const item = conversationStore.getConversation(selected.id) ?? selected;
|
|
if (!item.messageSummary) return item;
|
|
const snapshot = await window.goodbuddy.conversations.get(item.id);
|
|
// Export reads do not acquire a view-cache entry or retain tool metadata.
|
|
const merged = mergePersistedConversations([item], [snapshot], new Map())[0]!;
|
|
// Deltas that streamed in while the snapshot was read.
|
|
return liveMessages.resolveConversations([merged])[0]!;
|
|
};
|
|
|
|
const copyConversation = async (
|
|
item: Conversation,
|
|
): Promise<void> => {
|
|
let conversation: Conversation;
|
|
try { conversation = await readConversationForExport(item); }
|
|
catch {
|
|
notify({ tone: "error", message: t("notices.remoteConversationRefreshFailed") });
|
|
return;
|
|
}
|
|
const transcript = conversation.messages
|
|
.map((message) =>
|
|
t("chat.exportSpeaker", {
|
|
speaker: message.role === "user" ? t("chat.user") : "GoodBuddy",
|
|
content: `${message.content}${formatAttachmentList(
|
|
message.attachments,
|
|
t,
|
|
)}`,
|
|
}),
|
|
)
|
|
.join("\n\n");
|
|
await writeClipboardText(transcript, t("notices.conversationCopied"));
|
|
};
|
|
|
|
const copyMessage = useCallback(
|
|
(content: string, kind?: 'tool'): Promise<boolean> =>
|
|
writeClipboardText(content, kind === 'tool' ? t("chat.tools.copied") : undefined),
|
|
[t, writeClipboardText],
|
|
);
|
|
|
|
const exportConversation = async (item: Conversation): Promise<void> => {
|
|
let conversation: Conversation;
|
|
try { conversation = await readConversationForExport(item); }
|
|
catch {
|
|
notify({ tone: "error", message: t("notices.remoteConversationRefreshFailed") });
|
|
return;
|
|
}
|
|
const markdown = [
|
|
`# ${conversation.title}`,
|
|
"",
|
|
...conversation.messages.flatMap((message) => [
|
|
`## ${message.role === "user" ? t("chat.user") : "GoodBuddy"}`,
|
|
"",
|
|
`${message.content}${formatAttachmentList(message.attachments, t)}`,
|
|
"",
|
|
]),
|
|
].join("\n");
|
|
const blob = new Blob([markdown], {
|
|
type: "text/markdown;charset=utf-8",
|
|
});
|
|
const url = URL.createObjectURL(blob);
|
|
const anchor = document.createElement("a");
|
|
anchor.href = url;
|
|
anchor.download = `${
|
|
conversation.title.replace(/[\\/:*?"<>|]/g, "_") ||
|
|
t("conversation.exportFallbackName")
|
|
}.md`;
|
|
anchor.click();
|
|
URL.revokeObjectURL(url);
|
|
notify({ tone: "success", message: t("notices.conversationExported") });
|
|
};
|
|
|
|
const openImageViewer = useCallback(
|
|
(item: ImageViewerItem, trigger: HTMLElement): void => {
|
|
if (!imageDataUrlPattern.test(item.src)) {
|
|
notify({
|
|
tone: "error",
|
|
message: tRef.current("notices.imageUnavailable"),
|
|
});
|
|
return;
|
|
}
|
|
imageViewerTriggerRef.current = trigger;
|
|
setImageViewerItem(item);
|
|
},
|
|
[],
|
|
);
|
|
|
|
const closeImageViewer = (): void => {
|
|
const trigger = imageViewerTriggerRef.current;
|
|
setImageViewerItem(undefined);
|
|
imageViewerTriggerRef.current = undefined;
|
|
requestAnimationFrame(() => trigger?.focus());
|
|
};
|
|
|
|
const openCitationContext = useCallback(
|
|
async (reference: KnowledgeSearchReference): Promise<void> => {
|
|
const request = ++citationRequestRef.current;
|
|
if (reference.external) {
|
|
setCitationDialog({ reference, loading: false });
|
|
return;
|
|
}
|
|
setCitationDialog({
|
|
reference,
|
|
loading: true,
|
|
});
|
|
if (!reference.chunkId || !reference.documentId) {
|
|
setCitationDialog({
|
|
reference,
|
|
loading: false,
|
|
error: tRef.current("chat.citations.contextUnavailable"),
|
|
});
|
|
return;
|
|
}
|
|
try {
|
|
const context = await window.goodbuddy.knowledge.getReferenceContext({
|
|
knowledgeBaseId: reference.libraryId,
|
|
documentId: reference.documentId,
|
|
chunkId: reference.chunkId,
|
|
});
|
|
if (request !== citationRequestRef.current) return;
|
|
setCitationDialog({
|
|
reference,
|
|
loading: false,
|
|
context: {
|
|
libraryName: reference.libraryName,
|
|
documentName: context.documentTitle,
|
|
sourceName: context.sourceDisplayName,
|
|
locator: context.locator,
|
|
matchedContent: context.matchedContent,
|
|
contextContent: context.contextContent,
|
|
truncated: context.truncated,
|
|
},
|
|
});
|
|
} catch (reason) {
|
|
if (request !== citationRequestRef.current) return;
|
|
setCitationDialog({
|
|
reference,
|
|
loading: false,
|
|
error:
|
|
reason instanceof Error
|
|
? reason.message
|
|
: tRef.current("chat.citations.contextUnavailable"),
|
|
});
|
|
}
|
|
},
|
|
[],
|
|
);
|
|
|
|
const openCitationSource = useCallback(
|
|
async (reference: KnowledgeSearchReference): Promise<void> => {
|
|
if (reference.external || !reference.chunkId || !reference.documentId) {
|
|
return;
|
|
}
|
|
try {
|
|
await window.goodbuddy.knowledge.openReferenceSource({
|
|
knowledgeBaseId: reference.libraryId,
|
|
documentId: reference.documentId,
|
|
chunkId: reference.chunkId,
|
|
});
|
|
} catch (reason) {
|
|
notify({
|
|
tone: "error",
|
|
message:
|
|
reason instanceof Error
|
|
? reason.message
|
|
: tRef.current("chat.citations.openFailed"),
|
|
});
|
|
}
|
|
},
|
|
[],
|
|
);
|
|
|
|
const downloadImage = useCallback((item: ImageViewerItem): void => {
|
|
if (!imageDataUrlPattern.test(item.src)) {
|
|
notify({
|
|
tone: "error",
|
|
message: tRef.current("notices.imageUnavailable"),
|
|
});
|
|
return;
|
|
}
|
|
const anchor = document.createElement("a");
|
|
anchor.href = item.src;
|
|
anchor.download = getImageDownloadName(
|
|
item.title,
|
|
item.src,
|
|
tRef.current("chat.images.fallbackTitle"),
|
|
);
|
|
anchor.rel = "noopener";
|
|
anchor.click();
|
|
notify({
|
|
tone: "info",
|
|
message: tRef.current("notices.imageDownloadStarted"),
|
|
});
|
|
}, []);
|
|
|
|
const submit = async (
|
|
queuedDispatch?: ConversationQueueDispatch,
|
|
promptOverride?: string,
|
|
): Promise<void> => {
|
|
let queuedInput: ConversationQueueUserInput | undefined =
|
|
queuedDispatch && !queuedDispatch.scheduled ? queuedDispatch.input : undefined;
|
|
if (queuedDispatch?.scheduled) {
|
|
const conversation = conversationStore.getState().find(
|
|
(candidate) => candidate.id === queuedDispatch.input.conversationId,
|
|
);
|
|
const project = projectsRef.current.find(
|
|
(candidate) => candidate.id === conversation?.projectId,
|
|
);
|
|
const selection = runtimeSettings && conversation
|
|
? resolveConversationRuntime(project, conversation.runtimeSelection, runtimeSettings).selection
|
|
: undefined;
|
|
if (!conversation || !selection) {
|
|
await window.goodbuddy.conversationQueue.releaseUser(queuedDispatch.item.id);
|
|
return;
|
|
}
|
|
queuedInput = {
|
|
conversationId: conversation.id,
|
|
projectId: conversation.projectId,
|
|
prompt: queuedDispatch.input.prompt,
|
|
runtimeSelection: selection,
|
|
includeMemoryContext: true,
|
|
attachments: [],
|
|
knowledgeLibraryIds: conversation.knowledgeLibraryIds ?? [],
|
|
knowledgeRetrievalMode: conversation.knowledgeRetrievalMode ?? "auto",
|
|
smartRouting: runtimeSettings?.subagentSmartRoutingEnabled === true ? true : undefined,
|
|
};
|
|
}
|
|
const releaseQueuedItem = async (): Promise<void> => {
|
|
if (!queuedDispatch) {
|
|
return;
|
|
}
|
|
try {
|
|
await window.goodbuddy.conversationQueue.releaseUser(
|
|
queuedDispatch.item.id,
|
|
);
|
|
} catch {
|
|
notify({
|
|
tone: "error",
|
|
message: t("notices.conversationQueueReleaseFailed"),
|
|
});
|
|
}
|
|
};
|
|
let conversationSnapshot = conversationStore.getConversation(
|
|
queuedInput ? queuedInput.conversationId : activeId,
|
|
);
|
|
if (conversationSnapshot?.messageSummary) {
|
|
try {
|
|
conversationSnapshot = await ensureConversationHistory(conversationSnapshot.id);
|
|
} catch {
|
|
notify({ tone: "error", message: t("notices.remoteConversationRefreshFailed") });
|
|
await releaseQueuedItem();
|
|
return;
|
|
}
|
|
}
|
|
const recoveryProjectId =
|
|
queuedInput?.projectId ?? conversationSnapshot?.projectId;
|
|
if (
|
|
recoveryProjectId &&
|
|
((!projectRecoverySnapshotReadyRef.current &&
|
|
isManagedSshProject(
|
|
projectsRef.current.find(
|
|
(project) => project.id === recoveryProjectId,
|
|
),
|
|
)) ||
|
|
isProjectRecoveryUnsettled(
|
|
projectRecoveryByProjectIdRef.current[recoveryProjectId],
|
|
))
|
|
) {
|
|
await releaseQueuedItem();
|
|
return;
|
|
}
|
|
const command =
|
|
!queuedInput && activeRuntimeSelection?.provider === "opencode"
|
|
? runtimeNativeSnapshot?.commands.find(
|
|
(candidate) => candidate.id === selectedRuntimeCommand,
|
|
)
|
|
: undefined;
|
|
const commandArguments = queuedInput
|
|
? ""
|
|
: (promptOverride ?? composerDrafts.get(activeId)).trim();
|
|
const prompt =
|
|
queuedInput?.prompt ??
|
|
(command
|
|
? `/${command.name}${commandArguments ? ` ${commandArguments}` : ""}`
|
|
: commandArguments);
|
|
if (!prompt || !conversationSnapshot) {
|
|
await releaseQueuedItem();
|
|
return;
|
|
}
|
|
if (!queuedInput && (selectingContextFilesRef.current || attachmentOperationsRef.current > 0)) {
|
|
notify({
|
|
tone: "info",
|
|
message: t("composer.attachmentProgress.waitBeforeSending"),
|
|
});
|
|
return;
|
|
}
|
|
if (conversationSnapshot.remote) {
|
|
notify({
|
|
tone: "info",
|
|
message: t("notices.remoteConversationReadOnly"),
|
|
});
|
|
await releaseQueuedItem();
|
|
return;
|
|
}
|
|
if (!queuedInput && !runtime) {
|
|
notify({
|
|
tone: "info",
|
|
message: t("runtime.loadingRetry"),
|
|
});
|
|
return;
|
|
}
|
|
if (
|
|
!queuedInput &&
|
|
(runtimeSwitching || runtimeStatusKey !== activeRuntimeSelectionKey)
|
|
) {
|
|
notify({
|
|
tone: "info",
|
|
message: t("runtime.updatingRetry"),
|
|
});
|
|
return;
|
|
}
|
|
if (!queuedInput && !runtime?.available) {
|
|
return;
|
|
}
|
|
|
|
const requestId = queuedDispatch?.scheduled
|
|
? queuedDispatch.item.scheduleRunId!
|
|
: crypto.randomUUID();
|
|
const conversationId = conversationSnapshot.id;
|
|
const attachmentSnapshot = (queuedInput?.attachments ?? attachments).slice(
|
|
0,
|
|
8,
|
|
);
|
|
const historySnapshot = conversationSnapshot.messages;
|
|
const retainedHistorySnapshot = buildRuntimeHistory(historySnapshot);
|
|
const projectIdSnapshot = queuedInput
|
|
? queuedInput.projectId
|
|
: activeProjectId || undefined;
|
|
const knowledgeRetrievalModeSnapshot =
|
|
queuedInput?.knowledgeRetrievalMode ??
|
|
conversationSnapshot.knowledgeRetrievalMode ??
|
|
"auto";
|
|
// Queued messages follow the conversation's current choice at dispatch,
|
|
// so switching the model while messages wait applies to them too.
|
|
const runtimeSelectionSnapshot = queuedInput
|
|
? runtimeSettings
|
|
? resolveConversationRuntime(
|
|
projectsRef.current.find((project) => project.id === queuedInput!.projectId),
|
|
conversationSnapshot.runtimeSelection,
|
|
runtimeSettings,
|
|
).selection
|
|
: queuedInput.runtimeSelection
|
|
: activeRuntimeSelection;
|
|
if (!runtimeSelectionSnapshot) {
|
|
notify({ tone: "info", message: t("runtime.notSelected") });
|
|
await releaseQueuedItem();
|
|
return;
|
|
}
|
|
const runtimeControlSnapshot: RuntimeControl | undefined = queuedInput
|
|
? // A queued agent/command/preset only applies to the Runtime it was chosen for.
|
|
queuedInput.runtimeControl?.provider === runtimeSelectionSnapshot.provider
|
|
? queuedInput.runtimeControl
|
|
: undefined
|
|
: runtimeSelectionSnapshot.provider === "opencode" &&
|
|
(selectedRuntimeAgent || command)
|
|
? {
|
|
provider: "opencode",
|
|
...(selectedRuntimeAgent ? { agent: selectedRuntimeAgent } : {}),
|
|
...(command
|
|
? {
|
|
command: {
|
|
name: command.name,
|
|
arguments: commandArguments,
|
|
},
|
|
}
|
|
: {}),
|
|
}
|
|
: runtimeSelectionSnapshot.provider === "continue" &&
|
|
selectedContinuePreset
|
|
? {
|
|
provider: "continue",
|
|
presetId: selectedContinuePreset,
|
|
}
|
|
: undefined;
|
|
const selectedExpertSnapshot = queuedInput
|
|
? queuedInput.teamMode
|
|
? "team"
|
|
: (queuedInput.expertId ?? "")
|
|
: runtime?.capability === "image-generation"
|
|
? ""
|
|
: selectedExpertId;
|
|
const knowledgeLibraryIdsSnapshot =
|
|
queuedInput?.knowledgeLibraryIds ?? enabledKnowledgeLibraryIds;
|
|
const smartRoutingSnapshot =
|
|
queuedInput?.smartRouting ??
|
|
(!queuedInput &&
|
|
runtime?.capability !== "image-generation" &&
|
|
runtimeSettings?.subagentSmartRoutingEnabled === true &&
|
|
!selectedExpertSnapshot
|
|
? true
|
|
: undefined);
|
|
|
|
if (!queuedInput) {
|
|
const queueInput: ConversationQueueUserInput = {
|
|
conversationId,
|
|
...(projectIdSnapshot ? { projectId: projectIdSnapshot } : {}),
|
|
runtimeSelection: runtimeSelectionSnapshot,
|
|
...(runtimeControlSnapshot
|
|
? { runtimeControl: runtimeControlSnapshot }
|
|
: {}),
|
|
...(selectedExpertSnapshot && selectedExpertSnapshot !== "team"
|
|
? { expertId: selectedExpertSnapshot }
|
|
: {}),
|
|
...(selectedExpertSnapshot === "team" ? { teamMode: true } : {}),
|
|
...(smartRoutingSnapshot ? { smartRouting: true } : {}),
|
|
includeMemoryContext: !command,
|
|
prompt,
|
|
attachments: attachmentSnapshot,
|
|
imageContextArtifactIds: imageReferences.map(artifact => artifact.id),
|
|
knowledgeLibraryIds: knowledgeLibraryIdsSnapshot,
|
|
knowledgeRetrievalMode: knowledgeRetrievalModeSnapshot,
|
|
};
|
|
try {
|
|
persistLocalConversationChanges();
|
|
await conversationPersistence.idle();
|
|
if (
|
|
!conversationPersistence.acknowledged().has(conversationSnapshot.id)
|
|
) {
|
|
throw new Error(t("notices.conversationPersistenceFailed"));
|
|
}
|
|
await attachmentSaveQueue.current;
|
|
await window.goodbuddy.conversationQueue.enqueueUser(queueInput);
|
|
composerMenus.closeMenus();
|
|
setInput("");
|
|
updateAttachments([]);
|
|
setImageReferencesByConversation(current => ({ ...current, [conversationId]: [] }));
|
|
if (command) {
|
|
setSelectedRuntimeCommand("");
|
|
}
|
|
} catch (reason) {
|
|
notify({
|
|
tone: "error",
|
|
message: displayErrorMessage(reason, t("notices.sendFailed")),
|
|
});
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (!queuedDispatch || dispatchedConversationQueueItems.current.has(queuedDispatch.item.id)) {
|
|
return;
|
|
}
|
|
dispatchedConversationQueueItems.current.add(queuedDispatch.item.id);
|
|
composerMenus.closeMenus();
|
|
preparingConversations.current.add(conversationId);
|
|
clearConversationCompleted(conversationId);
|
|
setConversationActivity(conversationId, true);
|
|
const userMessage: Message = {
|
|
id: crypto.randomUUID(),
|
|
queueItemId: queuedDispatch.item.id,
|
|
role: "user",
|
|
content: prompt,
|
|
createdAt: Date.now(),
|
|
state: "complete",
|
|
attachments:
|
|
attachmentSnapshot.length > 0 ? attachmentSnapshot : undefined,
|
|
};
|
|
setConversations((current) =>
|
|
current.map((conversation) =>
|
|
conversation.id === conversationId
|
|
? {
|
|
...conversation,
|
|
title:
|
|
conversation.title === "新对话"
|
|
? prompt.slice(0, 24)
|
|
: conversation.title,
|
|
updatedAt: Date.now(),
|
|
messages: [...conversation.messages, userMessage],
|
|
}
|
|
: conversation,
|
|
),
|
|
);
|
|
const memoryContext = queuedInput.includeMemoryContext
|
|
? buildMemoryContext(assistantMemories)
|
|
: "";
|
|
const executionPrompt = memoryContext
|
|
? `${prompt}\n\n${memoryContext}`
|
|
: prompt;
|
|
const assistantMessage: Message = {
|
|
id: crypto.randomUUID(),
|
|
role: "assistant",
|
|
content: "",
|
|
blocks: [],
|
|
createdAt: Date.now(),
|
|
state: "streaming",
|
|
status: t("chat.status.preparingRequest"),
|
|
};
|
|
|
|
activeRuns.current.set(requestId, {
|
|
conversationId,
|
|
messageId: assistantMessage.id,
|
|
taskId: queuedDispatch?.scheduled ? queuedDispatch.item.taskId : undefined,
|
|
projectId: projectIdSnapshot,
|
|
runtimeSelectionKey: agentRuntimeSelectionKey(runtimeSelectionSnapshot),
|
|
});
|
|
preparingConversations.current.delete(conversationId);
|
|
const startedAt = new Date().toISOString();
|
|
setAssistantTasks((current) =>
|
|
[
|
|
{
|
|
id: requestId,
|
|
projectId: projectIdSnapshot,
|
|
conversationId,
|
|
title: prompt.slice(0, 120),
|
|
instructions: prompt,
|
|
origin: "user" as const,
|
|
status: "running" as const,
|
|
createdAt: startedAt,
|
|
startedAt,
|
|
},
|
|
...current,
|
|
].filter((task, index) =>
|
|
index < 100 || task.status === "running" || task.status === "waiting_approval",
|
|
),
|
|
);
|
|
recordActivity({
|
|
conversationId,
|
|
requestId,
|
|
kind: "request",
|
|
title: prompt.slice(0, 120),
|
|
detail: t("notices.userStartedTask"),
|
|
status: "running",
|
|
});
|
|
setConversations((current) =>
|
|
current.map((conversation) =>
|
|
conversation.id === conversationId
|
|
? {
|
|
...conversation,
|
|
updatedAt: Date.now(),
|
|
messages: [
|
|
...conversation.messages,
|
|
assistantMessage,
|
|
],
|
|
activeRequest: undefined,
|
|
}
|
|
: conversation,
|
|
),
|
|
);
|
|
try {
|
|
const saveOrigin = conversationPersistence.enqueue(async () => {
|
|
const origin = {
|
|
...conversationSnapshot,
|
|
title: conversationSnapshot.title === "新对话" ? prompt.slice(0, 24) : conversationSnapshot.title,
|
|
updatedAt: assistantMessage.createdAt,
|
|
messages: [...historySnapshot, userMessage, assistantMessage],
|
|
};
|
|
await window.goodbuddy.conversations.saveLocal([{
|
|
header: toLocalConversationHeader(origin),
|
|
messages: [toConversationMessage(userMessage), toConversationMessage(assistantMessage)],
|
|
}]);
|
|
conversationPersistence.acknowledged().set(conversationId, origin);
|
|
});
|
|
await saveOrigin;
|
|
await window.goodbuddy.agent.run({
|
|
requestId,
|
|
conversationId,
|
|
projectId: projectIdSnapshot,
|
|
queueItemId: queuedDispatch.item.id,
|
|
runtimeSelection: runtimeSelectionSnapshot,
|
|
runtimeControl: runtimeControlSnapshot,
|
|
expertId:
|
|
selectedExpertSnapshot && selectedExpertSnapshot !== "team"
|
|
? selectedExpertSnapshot
|
|
: undefined,
|
|
teamMode: selectedExpertSnapshot === "team",
|
|
smartRouting: smartRoutingSnapshot,
|
|
prompt: executionPrompt,
|
|
knowledgeLibraryIds: knowledgeLibraryIdsSnapshot,
|
|
knowledgeRetrievalMode: knowledgeRetrievalModeSnapshot,
|
|
contextIds: attachmentSnapshot.map((attachment) => attachment.id),
|
|
imageContextArtifactIds: queuedInput?.imageContextArtifactIds?.length
|
|
? queuedInput.imageContextArtifactIds
|
|
: attachmentSnapshot.some(attachment => attachment.kind === 'image') ? undefined : [...historySnapshot]
|
|
.reverse()
|
|
.find(
|
|
(message) =>
|
|
message.role === "assistant" &&
|
|
message.state === "complete" &&
|
|
message.artifactIds?.length,
|
|
)?.artifactIds,
|
|
contextCompressionState: conversationSnapshot.contextCompressionState,
|
|
history: retainedHistorySnapshot.map((message) => ({
|
|
role: message.role,
|
|
content: message.content,
|
|
})),
|
|
historyMessageIds: retainedHistorySnapshot.map((message) => message.id),
|
|
currentUserMessageId: userMessage.id,
|
|
currentAssistantMessageId: assistantMessage.id,
|
|
});
|
|
for (const attachment of attachmentSnapshot) {
|
|
void window.goodbuddy.context.remove(attachment.id);
|
|
}
|
|
} catch (error) {
|
|
preparingConversations.current.delete(conversationId);
|
|
activeRuns.current.delete(requestId);
|
|
setConversationActivity(conversationId, false);
|
|
for (const attachment of attachmentSnapshot) {
|
|
void window.goodbuddy.context.remove(attachment.id);
|
|
}
|
|
setConversations((current) =>
|
|
current.map((conversation) =>
|
|
conversation.id === conversationId
|
|
? {
|
|
...conversation,
|
|
title:
|
|
conversationSnapshot.title === "新对话" &&
|
|
conversation.title === prompt.slice(0, 24)
|
|
? conversationSnapshot.title
|
|
: conversation.title,
|
|
updatedAt: Date.now(),
|
|
messages: conversation.messages.filter(
|
|
(message) =>
|
|
message.id !== userMessage.id &&
|
|
message.id !== assistantMessage.id,
|
|
),
|
|
}
|
|
: conversation,
|
|
),
|
|
);
|
|
setAssistantTasks((current) =>
|
|
current.filter((task) => task.id !== requestId),
|
|
);
|
|
activityStore.removeByRequest(requestId);
|
|
notify({
|
|
tone: "error",
|
|
message: displayErrorMessage(error, t("notices.sendFailed")),
|
|
});
|
|
await releaseQueuedItem();
|
|
} finally {
|
|
dispatchedConversationQueueItems.current.delete(queuedDispatch.item.id);
|
|
}
|
|
};
|
|
|
|
useLayoutEffect(() => {
|
|
conversationQueueDispatchRef.current = (dispatch) => {
|
|
void submit(dispatch);
|
|
};
|
|
});
|
|
|
|
const compactRuntimeContext = async (): Promise<void> => {
|
|
if (
|
|
!activeConversation ||
|
|
!activeRuntimeSelection ||
|
|
!runtimeContextCompactAvailable ||
|
|
runtimeContextCompacting ||
|
|
isRunning
|
|
) {
|
|
return;
|
|
}
|
|
let completeConversation: Conversation;
|
|
try { completeConversation = await ensureConversationHistory(activeConversation.id); }
|
|
catch {
|
|
notify({ tone: "error", message: t("notices.remoteConversationRefreshFailed") });
|
|
return;
|
|
}
|
|
const history = buildRuntimeHistory(completeConversation.messages);
|
|
if (history.length < 2) {
|
|
notify({
|
|
tone: "info",
|
|
message: t("composer.context.nothingToCompact"),
|
|
dedupeKey: "runtime-context-compact",
|
|
});
|
|
return;
|
|
}
|
|
const requestId = crypto.randomUUID();
|
|
setRuntimeContextCompacting(true);
|
|
try {
|
|
const result = await window.goodbuddy.agent.compactConversation({
|
|
requestId,
|
|
conversationId: activeConversation.id,
|
|
projectId: activeConversation.projectId,
|
|
runtimeSelection: activeRuntimeSelection,
|
|
history: history.map((message) => ({
|
|
role: message.role,
|
|
content: message.content,
|
|
})),
|
|
historyMessageIds: history.map((message) => message.id),
|
|
contextCompressionState: activeConversation.contextCompressionState,
|
|
});
|
|
if (result.contextCompressionState) {
|
|
const state = result.contextCompressionState;
|
|
const remainingHistory = history.slice(
|
|
Math.min(state.coveredMessageCount, history.length),
|
|
);
|
|
const estimatedAfterTokens =
|
|
estimatedContextRequestOverheadTokens +
|
|
estimateMessagesTokens([
|
|
...buildConversationSummaryHistory(state.summary),
|
|
...remainingHistory.map((message) => ({
|
|
role: message.role,
|
|
content: message.content,
|
|
})),
|
|
]);
|
|
setConversations((current) =>
|
|
current.map((conversation) =>
|
|
conversation.id === activeConversation.id
|
|
? {
|
|
...conversation,
|
|
contextCompressionState: state,
|
|
contextMetrics: {
|
|
runtimeSelectionKey: agentRuntimeSelectionKey(activeRuntimeSelection),
|
|
contextTokens: estimatedAfterTokens,
|
|
source: "estimated",
|
|
basis: "conversation",
|
|
},
|
|
updatedAt: Date.now(),
|
|
}
|
|
: conversation,
|
|
),
|
|
);
|
|
}
|
|
notify({
|
|
tone: result.compacted ? "success" : "info",
|
|
message: result.detail,
|
|
dedupeKey: "runtime-context-compact",
|
|
});
|
|
} catch (reason) {
|
|
notify({
|
|
tone: "error",
|
|
message:
|
|
reason instanceof Error
|
|
? reason.message
|
|
: t("composer.context.compactFailed"),
|
|
dedupeKey: "runtime-context-compact",
|
|
});
|
|
} finally {
|
|
setRuntimeContextCompacting(false);
|
|
}
|
|
};
|
|
|
|
const stop = async (): Promise<void> => {
|
|
const requestId = [...activeRuns.current.entries()].find(
|
|
([, run]) => run.conversationId === activeId,
|
|
)?.[0] ?? conversationStore.getState().find(
|
|
conversation => conversation.id === activeId,
|
|
)?.activeRequest?.requestId;
|
|
if (requestId) {
|
|
try {
|
|
await window.goodbuddy.agent.cancel(requestId);
|
|
} catch {
|
|
notify({ tone: "error", message: t("notices.stopFailed") });
|
|
}
|
|
}
|
|
};
|
|
|
|
const respondToQuestion = useCallback(
|
|
async (
|
|
conversationId: string,
|
|
messageId: string,
|
|
questionId: string,
|
|
answers?: AgentQuestionAnswer[],
|
|
): Promise<void> => {
|
|
const pendingMessage = conversationStore.getState()
|
|
.find((conversation) => conversation.id === conversationId)
|
|
?.messages.find((message) => message.id === messageId);
|
|
const question = pendingMessage?.pendingQuestions?.[0];
|
|
if (!question || question.questionId !== questionId) {
|
|
return;
|
|
}
|
|
const taskId = question.requestId;
|
|
await window.goodbuddy.agent.respondQuestion(questionId, answers);
|
|
updateMessage(conversationId, messageId, (message) => {
|
|
const pendingQuestions = message.pendingQuestions?.filter((item) => item.questionId !== questionId);
|
|
const resumed = message.pendingQuestions?.some((item) => item.questionId === questionId) &&
|
|
!pendingQuestions?.length && !message.approval && message.state === "streaming";
|
|
if (resumed) {
|
|
setAssistantTasks((current) => current.map((task) =>
|
|
task.id === taskId && task.status === "waiting_approval"
|
|
? { ...task, status: "running" }
|
|
: task,
|
|
));
|
|
}
|
|
return {
|
|
...message,
|
|
answeredQuestions: [
|
|
...(message.answeredQuestions ?? []).filter((item) => item.questionId !== questionId),
|
|
{
|
|
questionId,
|
|
skipped: answers === undefined,
|
|
questions: question.questions.map((item, index) => ({
|
|
...item,
|
|
answer: answers?.[index],
|
|
})),
|
|
},
|
|
],
|
|
pendingQuestions,
|
|
status: resumed
|
|
? answers
|
|
? tRef.current("chat.status.answerSubmitted")
|
|
: tRef.current("chat.status.questionSkipped")
|
|
: message.status,
|
|
};
|
|
});
|
|
},
|
|
[updateMessage, conversationStore, setAssistantTasks],
|
|
);
|
|
|
|
const addContext = async (
|
|
action: () => Promise<ContextAttachment | ContextAttachment[]>,
|
|
): Promise<void> => {
|
|
const conversationId = activeId;
|
|
setContextError(undefined);
|
|
try {
|
|
await conversationPersistence.idle();
|
|
if (!conversationPersistence.acknowledged().has(conversationId)) {
|
|
const owner = conversationStore.getState().find((conversation) => conversation.id === conversationId);
|
|
if (!owner || owner.remote) throw new Error('附件目标会话不可编辑');
|
|
await window.goodbuddy.conversations.saveLocal([{ header: toLocalConversationHeader(owner), messages: owner.messages.map(toConversationMessage) }]);
|
|
}
|
|
const result = await action();
|
|
const selected = Array.isArray(result) ? result : [result];
|
|
const current = attachmentsRef.current.get(conversationId) ?? [];
|
|
const unique = selected.filter(
|
|
(item) => !current.some((existing) => existing.id === item.id),
|
|
);
|
|
const accepted = unique.slice(0, Math.max(0, maximumAttachmentsPerMessage - current.length));
|
|
for (const attachment of unique.slice(accepted.length)) {
|
|
void window.goodbuddy.context.remove(attachment.id);
|
|
}
|
|
updateAttachments([...current, ...accepted]);
|
|
if (accepted.length < unique.length) {
|
|
setContextError(t("composer.errors.attachmentLimit"));
|
|
}
|
|
} catch (reason) {
|
|
setContextError(
|
|
reason instanceof Error
|
|
? reason.message
|
|
: t("composer.errors.addContext"),
|
|
);
|
|
}
|
|
};
|
|
|
|
const editImage = useCallback((artifact: AssistantArtifact): void => {
|
|
const conversationId = activeConversationIdRef.current;
|
|
setContextError(undefined);
|
|
setImageReferencesByConversation(current => ({ ...current,
|
|
[conversationId]: [...(current[conversationId] ?? []).filter(item => item.id !== artifact.id), artifact].slice(-8),
|
|
}));
|
|
inputRef.current?.focus();
|
|
}, []);
|
|
|
|
const openImageModelSettings = useCallback((): void => {
|
|
setSettingsInitialCategory("model");
|
|
setView("settings");
|
|
}, [setView]);
|
|
|
|
const reselectImageSources = useCallback((operation: ImageOperation): void => {
|
|
if (operation.conversationId !== activeConversationIdRef.current) return;
|
|
setConversationInput(operation.conversationId, current => current || t("chat.images.recoveryPrompt", {
|
|
model: operation.modelProfileName ?? operation.modelName,
|
|
prompt: operation.input.prompt,
|
|
}));
|
|
inputRef.current?.focus();
|
|
attachmentButtonRef.current?.click();
|
|
}, [setConversationInput, t]);
|
|
|
|
const selectContextFiles = async (paths?: string[]): Promise<void> => {
|
|
if (selectingContextFilesRef.current) {
|
|
return;
|
|
}
|
|
selectingContextFilesRef.current = true;
|
|
setSelectingContextFiles(true);
|
|
setFileSelectionProgress(undefined);
|
|
try {
|
|
await addContext(() => paths
|
|
? window.goodbuddy.context.importFiles(paths, activeId)
|
|
: window.goodbuddy.context.selectFiles(activeId));
|
|
} finally {
|
|
selectingContextFilesRef.current = false;
|
|
setSelectingContextFiles(false);
|
|
setFileSelectionProgress(undefined);
|
|
}
|
|
};
|
|
|
|
const startWebSpeechInput = async (): Promise<void> => {
|
|
const SpeechRecognition = getSpeechRecognitionConstructor(window);
|
|
if (!SpeechRecognition) {
|
|
notify({
|
|
tone: "info",
|
|
message: t("composer.voice.unsupported"),
|
|
});
|
|
return;
|
|
}
|
|
setVoiceListening(true);
|
|
setVoiceRecording(false);
|
|
let started = false;
|
|
try {
|
|
const prepared = await prepareSpeechRecognition(
|
|
SpeechRecognition,
|
|
"zh-CN",
|
|
() => {
|
|
notify({
|
|
tone: "info",
|
|
message: t("composer.voice.downloadingPack"),
|
|
dedupeKey: "speech-status",
|
|
});
|
|
},
|
|
);
|
|
const { recognition } = prepared;
|
|
recognition.onresult = (event) => {
|
|
const transcript = event.results[0]?.[0]?.transcript?.trim();
|
|
if (transcript) {
|
|
setInput((current) =>
|
|
current ? `${current} ${transcript}` : transcript,
|
|
);
|
|
notify({
|
|
tone: "success",
|
|
message: t("composer.voice.transcribed"),
|
|
dedupeKey: "speech-status",
|
|
});
|
|
}
|
|
};
|
|
recognition.onerror = (event) => {
|
|
notify({
|
|
tone: "error",
|
|
message: describeSpeechRecognitionError(event),
|
|
dedupeKey: "speech-status",
|
|
});
|
|
setVoiceListening(false);
|
|
setVoiceRecording(false);
|
|
};
|
|
recognition.onend = () => {
|
|
setVoiceListening(false);
|
|
setVoiceRecording(false);
|
|
};
|
|
recognition.start();
|
|
started = true;
|
|
setVoiceRecording(true);
|
|
notify({
|
|
tone: "info",
|
|
message: prepared.local
|
|
? t("composer.voice.localListening")
|
|
: t("composer.voice.systemListening"),
|
|
dedupeKey: "speech-status",
|
|
});
|
|
} catch (reason) {
|
|
notify({
|
|
tone: "error",
|
|
message:
|
|
reason instanceof Error
|
|
? reason.message
|
|
: t("composer.voice.startFailed"),
|
|
dedupeKey: "speech-status",
|
|
});
|
|
} finally {
|
|
if (!started) {
|
|
setVoiceListening(false);
|
|
setVoiceRecording(false);
|
|
}
|
|
}
|
|
};
|
|
|
|
const startVoiceInput = async (): Promise<void> => {
|
|
const speech = window.goodbuddy.speech;
|
|
if (!speech) {
|
|
await startWebSpeechInput();
|
|
return;
|
|
}
|
|
const audioWindow = window as typeof window & {
|
|
webkitAudioContext?: typeof AudioContext;
|
|
};
|
|
const AudioContextType =
|
|
audioWindow.AudioContext ?? audioWindow.webkitAudioContext;
|
|
if (!navigator.mediaDevices?.getUserMedia || !AudioContextType) {
|
|
notify({
|
|
tone: "error",
|
|
message: t("composer.voice.microphoneUnavailable"),
|
|
dedupeKey: "speech-status",
|
|
});
|
|
return;
|
|
}
|
|
setVoiceListening(true);
|
|
setVoiceRecording(false);
|
|
voiceStartingRef.current = true;
|
|
try {
|
|
const recording = await startPcmRecording(
|
|
navigator.mediaDevices,
|
|
AudioContextType,
|
|
);
|
|
voiceStartingRef.current = false;
|
|
if (voiceDisposedRef.current) {
|
|
void recording.result.catch(() => undefined);
|
|
recording.cancel();
|
|
return;
|
|
}
|
|
voiceRecordingRef.current = recording;
|
|
setVoiceRecording(true);
|
|
notify({
|
|
tone: "info",
|
|
message: t("composer.voice.recording"),
|
|
dedupeKey: "speech-status",
|
|
});
|
|
void recording.result
|
|
.then(async ({ audio, sampleRate }) => {
|
|
voiceRecordingRef.current = undefined;
|
|
setVoiceRecording(false);
|
|
const requestId = crypto.randomUUID();
|
|
voiceRequestIdRef.current = requestId;
|
|
notify({
|
|
tone: "info",
|
|
message: t("composer.voice.localRecognizing"),
|
|
dedupeKey: "speech-status",
|
|
});
|
|
const result = await speech.transcribe({
|
|
requestId,
|
|
sampleRate,
|
|
audio,
|
|
});
|
|
if (voiceRequestIdRef.current !== requestId) {
|
|
return;
|
|
}
|
|
const transcript = result.text.trim();
|
|
if (!transcript) {
|
|
notify({
|
|
tone: "info",
|
|
message: t("composer.voice.noSpeech"),
|
|
dedupeKey: "speech-status",
|
|
});
|
|
return;
|
|
}
|
|
setInput((current) =>
|
|
current ? `${current} ${transcript}` : transcript,
|
|
);
|
|
notify({
|
|
tone: "success",
|
|
message: t("composer.voice.transcribed"),
|
|
dedupeKey: "speech-status",
|
|
});
|
|
})
|
|
.catch((reason: unknown) => {
|
|
notify({
|
|
tone:
|
|
reason instanceof Error && reason.name === "AbortError"
|
|
? "info"
|
|
: "error",
|
|
message:
|
|
reason instanceof Error && reason.name === "AbortError"
|
|
? t("composer.voice.cancelled")
|
|
: reason instanceof Error
|
|
? reason.message
|
|
: t("composer.voice.localFailed"),
|
|
dedupeKey: "speech-status",
|
|
});
|
|
})
|
|
.finally(() => {
|
|
voiceRequestIdRef.current = undefined;
|
|
setVoiceListening(false);
|
|
setVoiceRecording(false);
|
|
});
|
|
} catch (reason) {
|
|
voiceStartingRef.current = false;
|
|
setVoiceListening(false);
|
|
setVoiceRecording(false);
|
|
notify({
|
|
tone: "error",
|
|
message:
|
|
reason instanceof Error && reason.name === "NotAllowedError"
|
|
? t("composer.voice.permissionDenied")
|
|
: reason instanceof Error
|
|
? reason.message
|
|
: t("composer.voice.recordingStartFailed"),
|
|
dedupeKey: "speech-status",
|
|
});
|
|
}
|
|
};
|
|
|
|
const toggleVoiceInput = (): void => {
|
|
if (voiceStartingRef.current) {
|
|
return;
|
|
}
|
|
const recording = voiceRecordingRef.current;
|
|
if (recording) {
|
|
setVoiceRecording(false);
|
|
recording.stop();
|
|
notify({
|
|
tone: "info",
|
|
message: t("composer.voice.preparing"),
|
|
dedupeKey: "speech-status",
|
|
});
|
|
return;
|
|
}
|
|
const requestId = voiceRequestIdRef.current;
|
|
if (requestId) {
|
|
voiceRequestIdRef.current = undefined;
|
|
void window.goodbuddy.speech?.cancel(requestId);
|
|
notify({
|
|
tone: "info",
|
|
message: t("composer.voice.cancelled"),
|
|
dedupeKey: "speech-status",
|
|
});
|
|
setVoiceListening(false);
|
|
setVoiceRecording(false);
|
|
return;
|
|
}
|
|
void startVoiceInput();
|
|
};
|
|
|
|
const refreshSelectedKnowledge = async (): Promise<void> => {
|
|
await refreshKnowledge(knowledgeSnapshot.selectedLibraryId);
|
|
};
|
|
|
|
const createKnowledgeLibrary = async (
|
|
input: Parameters<typeof window.goodbuddy.knowledge.createLibrary>[0],
|
|
): Promise<void> => {
|
|
const library = await window.goodbuddy.knowledge.createLibrary(input);
|
|
setEnabledKnowledgeLibraryIds((current) => [...current, library.id]);
|
|
await refreshKnowledge(library.id);
|
|
};
|
|
|
|
const deleteKnowledgeLibrary = async (libraryId: string): Promise<void> => {
|
|
await window.goodbuddy.knowledge.deleteLibrary(libraryId);
|
|
await refreshKnowledge();
|
|
};
|
|
|
|
const runKnowledgeSourceAction = async <T,>(
|
|
action: () => Promise<T>,
|
|
): Promise<T> => {
|
|
setKnowledgeOperationCount((count) => {
|
|
const next = count + 1;
|
|
knowledgeOperationCountRef.current = next;
|
|
return next;
|
|
});
|
|
try {
|
|
const result = await action();
|
|
await refreshSelectedKnowledge();
|
|
return result;
|
|
} catch (error) {
|
|
await refreshSelectedKnowledge().catch(() => undefined);
|
|
throw error;
|
|
} finally {
|
|
setKnowledgeOperationCount((count) => {
|
|
const next = Math.max(0, count - 1);
|
|
knowledgeOperationCountRef.current = next;
|
|
return next;
|
|
});
|
|
}
|
|
};
|
|
const knowledgeWorkspaceActions = useKnowledgeWorkspaceActions({
|
|
notify,
|
|
t,
|
|
selectedLibraryId: knowledgeSnapshot.selectedLibraryId,
|
|
refreshKnowledge,
|
|
refreshSelectedKnowledge,
|
|
retryKnowledgeLoad,
|
|
runKnowledgeSourceAction,
|
|
createKnowledgeLibrary,
|
|
deleteKnowledgeLibrary,
|
|
setEnabledKnowledgeLibraryIds,
|
|
setKnowledgeSnapshot,
|
|
openModelSettings: openImageModelSettings,
|
|
showChatAndFocusComposer,
|
|
});
|
|
|
|
const openQuickNotes = useCallback((): void => {
|
|
if (!magicNotesEnabled) return;
|
|
setAssistantSidebarOpen(true);
|
|
setNotesOpenRequest(value => value + 1);
|
|
}, [magicNotesEnabled]);
|
|
const captureToNote = useCallback(async (conversationId: string, message?: Message, trigger?: HTMLElement): Promise<void> => {
|
|
if (!magicNotesEnabled || noteCapturePending.current || noteDraft.saving) return;
|
|
const snapshot = conversationStore.getState().find(item => item.id === conversationId);
|
|
if (!snapshot || (message && (message.state === 'streaming' || !message.content.trim()))) return;
|
|
if (!message && snapshot.messages.some(item => item.state === 'streaming')) {
|
|
notify({ tone: 'info', message: t('magicNotes:capture.wait') });
|
|
return;
|
|
}
|
|
noteCapturePending.current = true;
|
|
setNoteCaptureLoading(true);
|
|
const capturedAt = new Date().toISOString();
|
|
try {
|
|
const conversation = message ? snapshot : await ensureConversationHistory(conversationId);
|
|
const messages = message ? [message] : conversation.messages.filter(item => (item.role === 'user' || item.role === 'assistant') && item.content.trim());
|
|
if (!message && messages.some(item => item.state === 'streaming')) throw new Error(t('magicNotes:capture.wait'));
|
|
const text = message ? message.content : messages.map(item => `## ${t(item.role === 'user' ? 'magicNotes:capture.user' : 'magicNotes:capture.assistant')}\n\n${item.content}`).join('\n\n');
|
|
if (!text.trim()) return;
|
|
// Main validates source IDs against persisted messages, including newly completed replies.
|
|
persistLocalConversationChanges();
|
|
await conversationPersistence.idle();
|
|
if (!await guardNoteDraft()) return;
|
|
const title = conversation.title.slice(0, 100);
|
|
setNoteDraft({ text, initialText: text, title, initialTitle: title, targetId: '', newNote: false,
|
|
incomplete: message ? message.state !== 'complete' : undefined,
|
|
source: { kind: message ? 'message' : 'conversation', conversationId, messageIds: messages.map(item => item.id), capturedAt,
|
|
conversationTitle: conversation.title, projectId: conversation.projectId, projectName: conversation.projectId ? projectNames.get(conversation.projectId) : undefined } });
|
|
noteCaptureTrigger.current = trigger ?? noteTitleMenuRef.current;
|
|
openQuickNotes();
|
|
} catch (reason) { notify({ tone: 'error', message: displayErrorMessage(reason, t('magicNotes:errors.operationFailed')) }); }
|
|
finally { noteCapturePending.current = false; setNoteCaptureLoading(false); }
|
|
}, [magicNotesEnabled, noteDraft.saving, ensureConversationHistory, persistLocalConversationChanges, guardNoteDraft, setNoteDraft, projectNames, openQuickNotes, notify, t, conversationStore, conversationPersistence]);
|
|
const openNoteSource = async (source: MagicNoteSource, messageId?: string): Promise<'opened' | 'missing'> => {
|
|
let snapshot;
|
|
try { snapshot = await window.goodbuddy.conversations.get(source.conversationId); }
|
|
catch (reason) {
|
|
if (reason instanceof Error && /对话不存在(?:$|["'])/u.test(reason.message)) return 'missing';
|
|
throw reason;
|
|
}
|
|
requestWorkspaceLeave('chat', () => {
|
|
const next = mergePersistedConversations(conversationStore.getState(), [snapshot], conversationPersistence.acknowledged(), new Set([source.conversationId, ...retainedConversationDetailIds()]));
|
|
setConversations(next);
|
|
setActiveProjectId(snapshot.projectId ?? '');
|
|
setActiveId(source.conversationId);
|
|
setSearchQuery('');
|
|
commitView('chat');
|
|
const targetId = messageId ?? (source.kind === 'message' ? source.messageIds[0] : undefined);
|
|
if (targetId) {
|
|
const conversation = next.find(item => item.id === source.conversationId)!;
|
|
const index = conversation.messages.findIndex(item => item.id === targetId);
|
|
if (index < 0 || !snapshot.messages.some(message => message.id === targetId)) notify({ tone: 'info', message: t('magicNotes:capture.missingMessage') });
|
|
else {
|
|
setVisibleMessageCounts(current => ({ ...current, [source.conversationId]: Math.max(current[source.conversationId] ?? messageRenderBatchSize, conversation.messages.length - index) }));
|
|
setNoteMessageNavigation({ conversationId: source.conversationId, messageId: targetId, requestId: Date.now() });
|
|
}
|
|
}
|
|
});
|
|
return 'opened';
|
|
};
|
|
|
|
const clearActivity = activityStore.clear;
|
|
|
|
const openActivityConversation = useCallback((conversationId: string): void => {
|
|
const open = async (): Promise<void> => {
|
|
let conversation = conversationStore.getState().find(
|
|
(candidate) => candidate.id === conversationId,
|
|
);
|
|
if (!conversation) {
|
|
try {
|
|
conversation = await window.goodbuddy.conversations.get(conversationId);
|
|
const persisted = [conversation];
|
|
setConversations((current) => mergePersistedConversations(
|
|
current, persisted, conversationPersistence.acknowledged(),
|
|
));
|
|
} catch {
|
|
notify({ tone: "error", message: t("notices.remoteConversationRefreshFailed") });
|
|
return;
|
|
}
|
|
}
|
|
if (!conversation) {
|
|
notify({ tone: "info", message: t("notices.conversationDeleted") });
|
|
return;
|
|
}
|
|
setActiveProjectId(conversation.projectId ?? "");
|
|
setConversationActionsId("");
|
|
setSelectedAssistantTaskId(undefined);
|
|
setSearchQuery("");
|
|
setActiveId(conversationId);
|
|
setUnreadConversationIds((current) => {
|
|
if (!current.has(conversationId)) return current;
|
|
const next = new Set(current);
|
|
next.delete(conversationId);
|
|
return next;
|
|
});
|
|
commitView("chat");
|
|
if (narrowWindow) closeNarrowSidebar();
|
|
};
|
|
requestWorkspaceLeave("chat", () => { void open(); });
|
|
}, [closeNarrowSidebar, commitView, narrowWindow, requestWorkspaceLeave, setActiveId, t, setConversations, conversationStore, conversationPersistence]);
|
|
|
|
const openAssistantTask = (task: AssistantTask): void => {
|
|
if (!task.conversationId) {
|
|
notify({
|
|
tone: "info",
|
|
message: t("notices.conversationDeleted"),
|
|
});
|
|
return;
|
|
}
|
|
const conversation = conversationStore.getState().find(
|
|
(candidate) => candidate.id === task.conversationId,
|
|
);
|
|
if (!conversation) {
|
|
notify({
|
|
tone: "info",
|
|
message: t("notices.conversationDeleted"),
|
|
});
|
|
return;
|
|
}
|
|
if (task.projectId) {
|
|
setActiveProjectId(task.projectId);
|
|
}
|
|
setSelectedAssistantTaskId(task.id);
|
|
setExpandedTaskConversationIds((current) => {
|
|
const next = new Set(current);
|
|
next.add(conversation.id);
|
|
return next;
|
|
});
|
|
setActiveId(conversation.id);
|
|
setView("chat");
|
|
};
|
|
|
|
const openCustomTaskDialog = (
|
|
defaultDestination: CustomTaskDestination,
|
|
): void => {
|
|
if (!activeProject || activeProject.kind !== "user") {
|
|
notify({
|
|
tone: "info",
|
|
message: t("customTask.errors.projectUnavailable"),
|
|
});
|
|
return;
|
|
}
|
|
setCustomTaskDialog({ defaultDestination });
|
|
};
|
|
|
|
const createCustomTask = async (
|
|
input: Parameters<typeof window.goodbuddy.schedules.create>[0],
|
|
options?: CustomTaskCreateOptions,
|
|
): Promise<AssistantSchedule> => {
|
|
if (!options?.runImmediately && !(Date.parse(input.nextRunAt) > Date.now())) {
|
|
throw new Error(t("customTask.errors.futureTime"));
|
|
}
|
|
if (input.conversationId) {
|
|
persistLocalConversationChanges();
|
|
await conversationPersistence.idle();
|
|
}
|
|
const schedule = await window.goodbuddy.schedules.create({
|
|
...input,
|
|
runImmediately: options?.runImmediately ?? false,
|
|
});
|
|
setAssistantSchedules((current) => [
|
|
schedule,
|
|
...current.filter((item) => item.id !== schedule.id),
|
|
]);
|
|
setSelectedAssistantTaskId(schedule.taskId);
|
|
setExpandedTaskConversationIds((current) => {
|
|
const next = new Set(current);
|
|
next.add(schedule.conversationId);
|
|
return next;
|
|
});
|
|
|
|
const [conversationResult, taskResult, scheduleResult] =
|
|
await Promise.allSettled([
|
|
window.goodbuddy.conversations.listSummaries([...retainedConversationDetailIds(), schedule.conversationId]),
|
|
window.goodbuddy.tasks.list(),
|
|
window.goodbuddy.schedules.list(),
|
|
]);
|
|
if (conversationResult.status === "fulfilled") {
|
|
setConversations((current) =>
|
|
mergePersistedConversations(
|
|
current,
|
|
conversationResult.value,
|
|
conversationPersistence.acknowledged(),
|
|
retainedConversationDetailIds(),
|
|
),
|
|
);
|
|
} else {
|
|
notify({
|
|
tone: "error",
|
|
message: t("notices.remoteConversationRefreshFailed"),
|
|
dedupeKey: "custom-task-conversation-refresh",
|
|
});
|
|
}
|
|
if (taskResult.status === "fulfilled") {
|
|
setAssistantTasks(taskResult.value);
|
|
}
|
|
if (scheduleResult.status === "fulfilled") {
|
|
setAssistantSchedules(scheduleResult.value);
|
|
}
|
|
if (
|
|
taskResult.status === "rejected" ||
|
|
scheduleResult.status === "rejected"
|
|
) {
|
|
notify({
|
|
tone: "error",
|
|
message: t("notices.taskHistoryReadFailed"),
|
|
dedupeKey: "custom-task-discovery-refresh",
|
|
});
|
|
}
|
|
if (schedule.projectId) {
|
|
setActiveProjectId(schedule.projectId);
|
|
}
|
|
setActiveId(schedule.conversationId);
|
|
setView("chat");
|
|
return schedule;
|
|
};
|
|
|
|
const runAssistantSchedule = useCallback(async (scheduleId: string): Promise<void> => {
|
|
await window.goodbuddy.schedules.runNow(scheduleId);
|
|
await refreshTasks(taskStore);
|
|
notify({
|
|
tone: "success",
|
|
message: t("notices.scheduleStarted"),
|
|
});
|
|
}, [notify, t, taskStore]);
|
|
|
|
const setAssistantScheduleEnabled = useCallback(async (
|
|
scheduleId: string,
|
|
enabled: boolean,
|
|
): Promise<void> => {
|
|
await window.goodbuddy.schedules.setEnabled(scheduleId, enabled);
|
|
setAssistantSchedules((current) =>
|
|
current.map((schedule) =>
|
|
schedule.id === scheduleId ? { ...schedule, enabled } : schedule,
|
|
),
|
|
);
|
|
}, []);
|
|
|
|
const removeAssistantSchedule = useCallback(async (scheduleId: string): Promise<void> => {
|
|
await window.goodbuddy.schedules.remove(scheduleId);
|
|
setAssistantSchedules((current) =>
|
|
current.filter((schedule) => schedule.id !== scheduleId),
|
|
);
|
|
}, []);
|
|
|
|
// Row actions always run the latest App closures, while the handlers object
|
|
// passed to memoized rows keeps one identity for the App lifetime.
|
|
const conversationListRowHandlers = useStableHandlers<ConversationListRowHandlers>({
|
|
toggleTasks: (conversationId) =>
|
|
setExpandedTaskConversationIds((current) => {
|
|
const next = new Set(current);
|
|
if (next.has(conversationId)) {
|
|
next.delete(conversationId);
|
|
} else {
|
|
next.add(conversationId);
|
|
}
|
|
return next;
|
|
}),
|
|
select: (conversationId) => {
|
|
setConversationActionsId("");
|
|
setSelectedAssistantTaskId(undefined);
|
|
setActiveId(conversationId);
|
|
setUnreadConversationIds((current) => {
|
|
if (!current.has(conversationId)) {
|
|
return current;
|
|
}
|
|
const next = new Set(current);
|
|
next.delete(conversationId);
|
|
return next;
|
|
});
|
|
setView("chat");
|
|
if (narrowWindow) {
|
|
closeNarrowSidebar();
|
|
}
|
|
},
|
|
toggleActions: (conversationId) => {
|
|
setRenamingConversationId("");
|
|
setConfirmingConversationId("");
|
|
setConversationActionsId((current) =>
|
|
current === conversationId ? "" : conversationId,
|
|
);
|
|
},
|
|
// Ref callbacks run during commit, before the latest handlers are
|
|
// published, so this only touches the lifetime-stable trigger map.
|
|
registerActionTrigger: (conversationId, element) => {
|
|
if (element) {
|
|
conversationActionTriggers.set(conversationId, element);
|
|
} else {
|
|
conversationActionTriggers.delete(conversationId);
|
|
}
|
|
},
|
|
closeActions: (conversationId) => {
|
|
setConversationActionsId("");
|
|
setConfirmingConversationId("");
|
|
focusConversationActions(conversationId);
|
|
},
|
|
pin: (conversation) => {
|
|
setConversationActionsId("");
|
|
focusConversationActions(conversation.id);
|
|
void setConversationPinned(conversation);
|
|
},
|
|
branch: (conversation, disabledReason) => {
|
|
if (disabledReason) {
|
|
notify({ tone: "info", message: disabledReason });
|
|
return;
|
|
}
|
|
setConversationActionsId("");
|
|
void branchConversation(conversation);
|
|
},
|
|
startRename: (conversationId) => {
|
|
setConversationActionsId("");
|
|
setRenamingConversationId(conversationId);
|
|
},
|
|
copy: (conversation) => {
|
|
setConversationActionsId("");
|
|
void copyConversation(conversation).finally(() =>
|
|
focusConversationActions(conversation.id),
|
|
);
|
|
},
|
|
exportConversation: (conversation) => {
|
|
setConversationActionsId("");
|
|
void exportConversation(conversation);
|
|
focusConversationActions(conversation.id);
|
|
},
|
|
cancelDelete: () => setConfirmingConversationId(""),
|
|
confirmDelete: (conversationId) => void deleteConversation(conversationId),
|
|
requestDelete: (conversationId) => setConfirmingConversationId(conversationId),
|
|
saveTitle,
|
|
cancelRename: (conversationId) => {
|
|
setRenamingConversationId("");
|
|
focusConversationActions(conversationId);
|
|
},
|
|
openTask: (task) => {
|
|
openAssistantTask(task);
|
|
if (narrowWindow) {
|
|
closeNarrowSidebar();
|
|
}
|
|
},
|
|
viewAllTasks: (conversationId, firstTaskId) => {
|
|
setSelectedAssistantTaskId(firstTaskId);
|
|
setActiveId(conversationId);
|
|
setView("chat");
|
|
if (narrowWindow) {
|
|
closeNarrowSidebar();
|
|
}
|
|
},
|
|
});
|
|
const conversationSidebarActions = useStableHandlers<ConversationSidebarActions>({
|
|
newConversation: () => void newConversation(),
|
|
clearSearch: () => setSearchQuery(""),
|
|
retryLoad: () => {
|
|
setConversationLoadError(undefined);
|
|
setConversationLoadRetry((current) => current + 1);
|
|
},
|
|
notify,
|
|
});
|
|
|
|
const clearLocalData = async (): Promise<void> => {
|
|
conversationPersistence.setPaused(true);
|
|
try {
|
|
await conversationPersistence.idle();
|
|
for (const requestId of activeRuns.current.keys()) {
|
|
await window.goodbuddy.agent.cancel(requestId);
|
|
}
|
|
activeRuns.current.clear();
|
|
setActiveConversationIds(new Set());
|
|
for (const attachments of attachmentsRef.current.values()) {
|
|
for (const attachment of attachments) {
|
|
await window.goodbuddy.context.remove(attachment.id);
|
|
}
|
|
}
|
|
attachmentsRef.current.clear();
|
|
setAttachmentsByConversation({});
|
|
for (const library of knowledgeSnapshot.libraries) {
|
|
await window.goodbuddy.knowledge.deleteLibrary(library.id);
|
|
}
|
|
await window.goodbuddy.app.clearLocalData();
|
|
const conversation = createConversation(
|
|
activeProjectId || undefined,
|
|
undefined,
|
|
t("conversation.greeting"),
|
|
);
|
|
conversationPersistence.acknowledged().clear();
|
|
setConversations([conversation]);
|
|
setActiveId(conversation.id);
|
|
activityStore.reset();
|
|
setAssistantTasks([]);
|
|
setTokenUsage(emptyTokenUsage);
|
|
setAssistantArtifacts([]);
|
|
setAssistantMemories([]);
|
|
setAssistantSchedules([]);
|
|
setAssistantHeartbeats([]);
|
|
setHeartbeatEntries([]);
|
|
setHeartbeatRuns([]);
|
|
setHeartbeatMemories([]);
|
|
setKnowledgeSnapshot({
|
|
libraries: [],
|
|
sources: [],
|
|
documents: [],
|
|
graphNodes: [],
|
|
graphRelations: [],
|
|
evidence: [],
|
|
});
|
|
updateAttachments([]);
|
|
setInput("");
|
|
setView("chat");
|
|
notify({
|
|
tone: "success",
|
|
message: t("notices.localDataCleared"),
|
|
});
|
|
} finally {
|
|
conversationPersistence.setPaused(false);
|
|
persistLocalConversationChanges();
|
|
}
|
|
};
|
|
|
|
const isRunning = activeConversation?.running ?? false;
|
|
const activeConversationQueueItems = useMemo(
|
|
() =>
|
|
conversationQueueItems.filter((item) => item.conversationId === activeId),
|
|
[activeId, conversationQueueItems],
|
|
);
|
|
const activeConversationHasBusyTask = useConversationHasBusyTask(taskStore, activeId);
|
|
const conversationExecutionRunning = isRunning || activeConversationHasBusyTask;
|
|
const handleConversationQueueError = useCallback(
|
|
(message: string): void => {
|
|
notify({
|
|
tone: "error",
|
|
message,
|
|
});
|
|
},
|
|
[notify],
|
|
);
|
|
const interruptConversationQueueItem = useCallback(
|
|
(itemId: string) =>
|
|
window.goodbuddy.conversationQueue.interruptAndRun(itemId),
|
|
[],
|
|
);
|
|
const removeConversationQueueItem = useCallback(
|
|
(itemId: string) => window.goodbuddy.conversationQueue.remove(itemId),
|
|
[],
|
|
);
|
|
const runtimeContextCompactAvailable =
|
|
activeRuntimeSelection?.provider === "model"
|
|
? !activeConversation?.remote &&
|
|
activeProject?.executionSpace.kind !== "ssh" &&
|
|
runtimeSettings?.modelProfiles.some(
|
|
(profile) =>
|
|
profile.id === activeRuntimeSelection.profileId &&
|
|
profile.protocol !== "openai-images-generations",
|
|
) === true
|
|
: (activeRuntimeSelection?.provider === "opencode" ||
|
|
activeRuntimeSelection?.provider === "continue") &&
|
|
runtimeNativeSnapshot?.context.manualCompact === true;
|
|
|
|
const nativeClientAvailable = activeRuntimeSelection?.provider === "continue" ||
|
|
activeRuntimeSelection?.provider === "opencode" ||
|
|
(activeRuntimeSelection?.provider === "deepseek-harness" && activeProject?.executionSpace.kind === "local");
|
|
const nativeClientContextKey = useMemo(() => JSON.stringify([
|
|
activeId, activeProjectId, activeRuntimeSelection, runtimeSettings,
|
|
]), [activeId, activeProjectId, activeRuntimeSelection, runtimeSettings]);
|
|
const prepareNativeClientConversation = async (): Promise<string> => {
|
|
let conversation = conversationStore.getConversation(activeId);
|
|
if (!conversation) {
|
|
conversation = await new Promise<Conversation>((resolve, reject) => {
|
|
if (!startNewConversation(activeProjectId || undefined, { ready: resolve })) {
|
|
reject(new Error(t("notices.channelConversationAutomatic")));
|
|
}
|
|
});
|
|
setActiveId(conversation.id);
|
|
}
|
|
// Save the current selection before Main resolves the launch from its conversation ID.
|
|
const header = toLocalConversationHeader(conversation);
|
|
await conversationPersistence.enqueue(() =>
|
|
window.goodbuddy.conversations.saveLocal([{ header, messages: [] }]),
|
|
);
|
|
return conversation.id;
|
|
};
|
|
|
|
const composerActions = useComposerActions({
|
|
submit: () => void submit(),
|
|
stop: () => void stop(),
|
|
selectContextFiles: (paths) => void selectContextFiles(paths),
|
|
addContext: (action) => void addContext(action),
|
|
isSelectingContextFiles: () => selectingContextFilesRef.current,
|
|
setContextError,
|
|
removeAttachment: (attachmentId) => {
|
|
void window.goodbuddy.context.remove(attachmentId);
|
|
updateAttachments((current) => current.filter((item) => item.id !== attachmentId));
|
|
},
|
|
removeImageReference: (conversationId, artifactId) =>
|
|
setImageReferencesByConversation((current) => ({
|
|
...current,
|
|
[conversationId]: (current[conversationId] ?? []).filter((item) => item.id !== artifactId),
|
|
})),
|
|
restoreQueueItem: async (conversationId, itemId) => {
|
|
await attachmentSaveQueue.current;
|
|
const restored = await window.goodbuddy.conversationQueue.restoreToDraft(itemId, "");
|
|
setConversationInput(conversationId, (current) =>
|
|
[current, restored.prompt].filter(Boolean).join("\n\n"));
|
|
},
|
|
interruptQueueItem: interruptConversationQueueItem,
|
|
removeQueueItem: removeConversationQueueItem,
|
|
queueError: handleConversationQueueError,
|
|
toggleVoiceInput,
|
|
compactRuntimeContext: () => void compactRuntimeContext(),
|
|
openImageViewer,
|
|
openModelSettings: openImageModelSettings,
|
|
setEnabledKnowledgeLibraryIds,
|
|
setStoryGraphEnabled: async (conversationId, enabled) => {
|
|
persistLocalConversationChanges();
|
|
await conversationPersistence.enqueue(async () => {
|
|
await window.goodbuddy.conversations.setStoryGraph({ conversationId, enabled });
|
|
setConversations((current) => current.map((conversation) =>
|
|
conversation.id === conversationId
|
|
? { ...conversation, storyGraphEnabled: enabled, updatedAt: Date.now() }
|
|
: conversation));
|
|
});
|
|
},
|
|
setKnowledgeRetrievalMode: (mode) =>
|
|
setConversations((current) =>
|
|
current.map((conversation) =>
|
|
conversation.id === activeId
|
|
? { ...conversation, knowledgeRetrievalMode: mode, updatedAt: Date.now() }
|
|
: conversation,
|
|
),
|
|
),
|
|
selectExpert: setSelectedExpertId,
|
|
selectRuntimeAgent: setSelectedRuntimeAgent,
|
|
selectContinuePreset: setSelectedContinuePreset,
|
|
selectRuntimeAction,
|
|
switchRuntime: (layer) => void switchRuntime(layer),
|
|
prepareNativeClientConversation,
|
|
openNativeTerminal: (terminal, origin) => {
|
|
const focus = activeProjectIdRef.current === origin.projectId &&
|
|
activeConversationIdRef.current === origin.conversationId && viewRef.current === "chat";
|
|
setNativeTerminals((current) => [...current, { terminal, focus }]);
|
|
if (focus) setAssistantSidebarOpen(true);
|
|
},
|
|
notify,
|
|
});
|
|
|
|
const mainSidebarOpen = narrowWindow && sidebarOpen;
|
|
const canResizePrimarySidebar = sidebarOpen && !narrowWindow;
|
|
const primarySidebarWidthLimits = getPrimarySidebarWidthLimits(
|
|
window.innerWidth,
|
|
);
|
|
const backgroundIsolated = mainSidebarOpen;
|
|
const runBrowserCommand = async (
|
|
command: (
|
|
browserApi: NonNullable<typeof window.goodbuddy.browser>,
|
|
) => Promise<void>,
|
|
): Promise<void> => {
|
|
const browserApi = window.goodbuddy.browser;
|
|
if (!browserApi) {
|
|
notify({
|
|
tone: "error",
|
|
message: t("notices.browserControlUnavailable"),
|
|
});
|
|
return;
|
|
}
|
|
await command(browserApi);
|
|
};
|
|
|
|
// Stable callbacks for the memoized routes and sidebars: App re-renders on
|
|
// chat updates, and fresh inline closures would re-render all of them.
|
|
const projectSwitcherActions = useStableHandlers({
|
|
onArchive: archiveProject,
|
|
onRestore: async (projectId: string) => setProjects(await restoreProject(projectId, conversationStore, conversationPersistence, retainedConversationDetailIds)),
|
|
notify,
|
|
onCreate: createProject,
|
|
onDelete: deleteProject,
|
|
onRemoteCommitted: loadCommittedRemoteProject,
|
|
onSelect: (projectId: string) => requestWorkspaceLeave('chat', () => { selectProject(projectId); if (narrowWindow) closeNarrowSidebar(); }),
|
|
onNewConversation: (projectId: string) => requestWorkspaceLeave('chat', () => {
|
|
startNewConversation(projectId, { ready: (conversation) => {
|
|
setActiveProjectId(projectId);
|
|
setActiveId(conversation.id);
|
|
commitView('chat');
|
|
requestAnimationFrame(() => inputRef.current?.focus());
|
|
if (narrowWindow) closeNarrowSidebar();
|
|
} });
|
|
}),
|
|
onSelectRoot: () => window.goodbuddy.settings.selectWorkspace(),
|
|
onUpdate: updateProject,
|
|
});
|
|
const magicNotesActions = useStableHandlers({
|
|
onOpenSource: openNoteSource,
|
|
onCancelNoteCapture: () => requestAnimationFrame(() => {
|
|
const trigger = noteCaptureTrigger.current;
|
|
(trigger?.isConnected && !trigger.closest('[hidden], [inert]') ? trigger : noteTitleMenuRef.current)?.focus();
|
|
}),
|
|
onOpenNoteWorkspace: (noteId: string, entryId?: string) =>
|
|
requestWorkspaceLeave('magic-notes', () => {
|
|
setNotesNavigation({ noteId, entryId, requestId: Date.now() });
|
|
commitView('magic-notes');
|
|
}),
|
|
});
|
|
const heartbeatActions = useStableHandlers({
|
|
onRetryApplicationSettings: () => void reloadApplicationSettings(),
|
|
onSetMemoryStatus: setMemoryStatus,
|
|
onSetTaskStatus: setHeartbeatTaskStatus,
|
|
onUseFollowUpTask: useHeartbeatTask,
|
|
});
|
|
const settingsPanelActions = useStableHandlers({
|
|
onTransparentFrostedEffectEnabledChange: (enabled: boolean) =>
|
|
updateApplicationSettings({ transparentFrostedEffectEnabled: enabled }),
|
|
onRetryApplicationSettings: () => void reloadApplicationSettings(),
|
|
onBrandingPreferencesChange: (preferences: Parameters<typeof saveBrandingPreferences>[0]) => {
|
|
if (!saveBrandingPreferences(preferences)) {
|
|
return false;
|
|
}
|
|
setBrandingPreferences(preferences);
|
|
notify({
|
|
tone: "success",
|
|
message: t("notices.brandingSaved"),
|
|
dedupeKey: "branding-saved",
|
|
});
|
|
return true;
|
|
},
|
|
onClearLocalData: clearLocalData,
|
|
onClose: () => {
|
|
commitView(viewRef.current);
|
|
},
|
|
onExpertsChanged: (experts: AssistantExpert[]) => {
|
|
setAssistantExperts(experts);
|
|
if (
|
|
(selectedExpertId === "team" && experts.length < 2) ||
|
|
(selectedExpertId &&
|
|
selectedExpertId !== "team" &&
|
|
!experts.some((expert) => expert.id === selectedExpertId))
|
|
) {
|
|
setSelectedExpertId("");
|
|
}
|
|
},
|
|
onRemoteProjectsEnabledChange: handleRemoteProjectsEnabledChange,
|
|
onProjectsDeleted: removeProjectsFromUi,
|
|
onSaved: (settings: RuntimeSettings) => {
|
|
setRuntimeSettings(settings);
|
|
},
|
|
onUpdateProject: updateProject,
|
|
});
|
|
const rightSidebarActions = useStableHandlers<RightSidebarHandlers>({
|
|
onBeforeCloseNotes: async () => {
|
|
if (!await guardNoteDraft()) return false;
|
|
setNoteDraft(undefined);
|
|
return true;
|
|
},
|
|
onOpenSupervisionGraph: (resultId) => {
|
|
requestWorkspaceLeave('heartbeat', () => {
|
|
setSupervisionGraphNavigation({ resultId });
|
|
commitView('heartbeat');
|
|
});
|
|
},
|
|
onContinueSupervision: async (prompt, conversationId) => {
|
|
await window.goodbuddy.supervision.continue({
|
|
conversationId,
|
|
prompt,
|
|
});
|
|
openActivityConversation(conversationId);
|
|
},
|
|
onCreateCustomTask: () => openCustomTaskDialog("current"),
|
|
onBackBrowser: (conversationId, tabId) =>
|
|
runBrowserCommand((browserApi) =>
|
|
browserApi.back({ conversationId, tabId }),
|
|
),
|
|
onNavigateBrowser: (conversationId, tabId, url) =>
|
|
runBrowserCommand((browserApi) =>
|
|
browserApi.navigate({ conversationId, tabId, url }),
|
|
),
|
|
onReloadBrowser: (conversationId, tabId) =>
|
|
runBrowserCommand((browserApi) =>
|
|
browserApi.reload({ conversationId, tabId }),
|
|
),
|
|
onStopLoadingBrowser: (conversationId, tabId) =>
|
|
runBrowserCommand((browserApi) =>
|
|
browserApi.stopLoading({ conversationId, tabId }),
|
|
),
|
|
onOpenTask: openAssistantTask,
|
|
});
|
|
const notesPanelActive = assistantSidebarOpen && magicNotesEnabled;
|
|
const notesPanel = useMemo(
|
|
() => (
|
|
<MagicNotesPanel
|
|
state={noteDraft}
|
|
active={notesPanelActive}
|
|
commentMode={applicationSettings?.magicNoteCommentMode}
|
|
commentFormat={applicationSettings?.magicNoteCommentFormat}
|
|
onNotify={notify}
|
|
onOpenSource={magicNotesActions.onOpenSource}
|
|
onCancelCapture={magicNotesActions.onCancelNoteCapture}
|
|
onOpenWorkspace={magicNotesActions.onOpenNoteWorkspace}
|
|
/>
|
|
),
|
|
[
|
|
applicationSettings?.magicNoteCommentFormat,
|
|
applicationSettings?.magicNoteCommentMode,
|
|
magicNotesActions,
|
|
noteDraft,
|
|
notesPanelActive,
|
|
],
|
|
);
|
|
const statsConversationId = statsConversation?.id;
|
|
const statsDurationMs = executionStats.conversation?.durationMs;
|
|
const statsIncomplete = executionStats.conversation?.incomplete ?? false;
|
|
const conversationStats = useMemo(
|
|
() =>
|
|
statsConversationId && statsDurationMs !== undefined
|
|
? {
|
|
conversationId: statsConversationId,
|
|
messageCount: statsMessageCount,
|
|
replyDurationMs: statsDurationMs,
|
|
incomplete: statsIncomplete,
|
|
}
|
|
: undefined,
|
|
[statsConversationId, statsDurationMs, statsIncomplete, statsMessageCount],
|
|
);
|
|
const activeWorkspaceChanges =
|
|
workspaceChanges?.projectId === activeProjectId
|
|
? workspaceChanges.changes
|
|
: undefined;
|
|
|
|
return (
|
|
<div className="app-shell" data-frosted-glass={applicationSettings?.transparentFrostedEffectEnabled ? 'true' : undefined}>
|
|
<LiveMessageStoreContext value={liveMessages}>
|
|
<ConversationStoreEffects
|
|
liveMessages={liveMessages}
|
|
onCommit={flushConversationPersistenceAfterCommit}
|
|
store={conversationStore}
|
|
/>
|
|
<DocumentConversationContext value={{
|
|
activeId: activeConversation?.remote ? undefined : activeId,
|
|
create: () => new Promise((resolve, reject) => {
|
|
const created = startNewConversation(activeProjectId || undefined, { ready: (conversation) => {
|
|
void window.goodbuddy.conversations.saveLocal([{ header: toLocalConversationHeader(conversation), messages: conversation.messages.map(toConversationMessage) }])
|
|
.then(() => resolve({ id: conversation.id, title: conversation.title }), reject);
|
|
} });
|
|
if (!created) reject(new Error('当前项目不能创建会话，请先选择普通项目'));
|
|
}),
|
|
navigate: (id) => { setActiveId(id); setView('chat'); },
|
|
notify: (message) => notify({ tone: 'success', message }),
|
|
openImage: (src, title, trigger) => { imageViewerTriggerRef.current = trigger; setImageViewerItem({ src, title }); }
|
|
}}>
|
|
<aside
|
|
aria-label={
|
|
narrowWindow && sidebarOpen ? t("sidebar.label") : undefined
|
|
}
|
|
aria-hidden={!sidebarOpen}
|
|
aria-modal={narrowWindow && sidebarOpen ? "true" : undefined}
|
|
className={
|
|
sidebarOpen
|
|
? `sidebar${
|
|
primarySidebarResizing && canResizePrimarySidebar
|
|
? " sidebar--resizing"
|
|
: ""
|
|
}`
|
|
: "sidebar sidebar--closed"
|
|
}
|
|
id="primary-sidebar"
|
|
inert={!sidebarOpen}
|
|
onKeyDown={(event) => {
|
|
if (mainSidebarOpen && event.currentTarget.contains(event.target as Node)) {
|
|
trapTabFocus(event, sidebarRef.current);
|
|
}
|
|
}}
|
|
ref={sidebarRef}
|
|
role={narrowWindow && sidebarOpen ? "dialog" : undefined}
|
|
style={
|
|
{
|
|
"--primary-sidebar-width": `${primarySidebarWidth}px`,
|
|
} as React.CSSProperties
|
|
}
|
|
>
|
|
<BrandLockup
|
|
className="brand"
|
|
copyClassName="brand__copy"
|
|
logo={
|
|
brandingPreferences.logoDataUrl ??
|
|
(resolvedAppearanceTheme === "dark"
|
|
? goodbuddyDarkIcon
|
|
: goodbuddyLightIcon)
|
|
}
|
|
markClassName="brand__mark"
|
|
name={brandingPreferences.name}
|
|
subtitle={brandingSubtitle || undefined}
|
|
/>
|
|
|
|
<ProjectSwitcher
|
|
activeProjectId={activeProjectId}
|
|
conversationStore={conversationStore}
|
|
activities={projectActivity.activities}
|
|
visible={sidebarOpen}
|
|
onOpenConversation={openActivityConversation}
|
|
activityByProjectId={projectActivity.byProjectId}
|
|
recoveryByProjectId={projectRecoveryByProjectId}
|
|
runtimeSettings={runtimeSettings}
|
|
{...projectSwitcherActions}
|
|
onRetryRecovery={retryProjectRecovery}
|
|
projects={projects}
|
|
remoteProjectsEnabled={remoteProjectsEnabled}
|
|
/>
|
|
|
|
<div
|
|
className={`sidebar-conversation-controls${searchOpen ? " sidebar-conversation-controls--searching" : ""}`}
|
|
onKeyDown={(event) => {
|
|
if (searchOpen && event.key === "Escape") {
|
|
event.preventDefault();
|
|
event.stopPropagation();
|
|
closeConversationSearch();
|
|
}
|
|
}}
|
|
>
|
|
{activeProject?.kind !== "channel" && (
|
|
<button
|
|
className="new-chat"
|
|
onClick={newConversation}
|
|
type="button"
|
|
aria-label={t("sidebar.newConversation")}
|
|
title={t("sidebar.newConversation")}
|
|
>
|
|
<MessageSquarePlus aria-hidden="true" size={17} />
|
|
{!searchOpen && <span>{t("sidebar.newConversation")}</span>}
|
|
</button>
|
|
)}
|
|
<div className="sidebar-search-slot">
|
|
{searchOpen ? (
|
|
<div className="sidebar-search">
|
|
<input
|
|
autoFocus
|
|
aria-label={t("sidebar.searchLabel")}
|
|
onChange={(event) => setSearchQuery(event.target.value)}
|
|
placeholder={t("sidebar.searchPlaceholder")}
|
|
value={searchQuery}
|
|
/>
|
|
<button
|
|
aria-label={t("sidebar.closeSearch")}
|
|
className="icon-button sidebar-search__clear"
|
|
onClick={closeConversationSearch}
|
|
title={t("sidebar.closeSearch")}
|
|
type="button"
|
|
>
|
|
<X aria-hidden="true" size={16} />
|
|
</button>
|
|
</div>
|
|
) : (
|
|
<button
|
|
ref={searchTriggerRef}
|
|
className="icon-button sidebar-search-trigger"
|
|
aria-label={t("sidebar.searchLabel")}
|
|
aria-expanded={false}
|
|
title={t("sidebar.searchLabel")}
|
|
onClick={() => setSearchOpen(true)}
|
|
type="button"
|
|
>
|
|
<Search aria-hidden="true" size={17} />
|
|
</button>
|
|
)}
|
|
</div>
|
|
</div>
|
|
|
|
<nav className="primary-nav" aria-label={t("navigation.label")}>
|
|
<button
|
|
aria-current={view === "chat" ? "page" : undefined}
|
|
className={
|
|
view === "chat" ? "nav-item nav-item--active" : "nav-item"
|
|
}
|
|
onClick={(event) =>
|
|
navigateFromSidebar("chat", event.currentTarget)
|
|
}
|
|
type="button"
|
|
>
|
|
<MessageSquare aria-hidden="true" size={17} />
|
|
<span>{t("navigation.chat")}</span>
|
|
</button>
|
|
{visibleApplications.map((id) => {
|
|
const definition = applicationDefinitions[id];
|
|
const Icon = definition.icon;
|
|
return (
|
|
<button
|
|
key={id}
|
|
type="button"
|
|
className={view === id ? "nav-item nav-item--active" : "nav-item"}
|
|
aria-current={view === id ? "page" : undefined}
|
|
onClick={(event) => navigateFromSidebar(id, event.currentTarget)}
|
|
onFocus={() => preloadWorkspaceRouteOnIntent(id)}
|
|
onPointerEnter={() => preloadWorkspaceRouteOnIntent(id)}
|
|
>
|
|
<Icon size={17} aria-hidden="true" />
|
|
<span>{t(definition.title)}</span>
|
|
{id === "magic-notes" && magicNotesShowIncompleteTodoCount && incompleteMagicTodoCount > 0 && (
|
|
<span className="nav-item__badge" aria-label={t("navigation.incompleteTodos", { count: incompleteMagicTodoCount })}>
|
|
{incompleteMagicTodoCount > 99 ? "99+" : incompleteMagicTodoCount}
|
|
</span>
|
|
)}
|
|
{id === "heartbeat" && pendingHeartbeatSuggestionCount > 0 && (
|
|
<span className="nav-item__badge" aria-label={t("navigation.pendingSuggestions", { count: pendingHeartbeatSuggestionCount })}>
|
|
{pendingHeartbeatSuggestionCount}
|
|
</span>
|
|
)}
|
|
</button>
|
|
);
|
|
})}
|
|
<button
|
|
aria-current={view === "activity" ? "page" : undefined}
|
|
className={
|
|
view === "activity" ? "nav-item nav-item--active" : "nav-item"
|
|
}
|
|
onFocus={() => preloadWorkspaceRouteOnIntent("activity")}
|
|
onClick={(event) =>
|
|
navigateFromSidebar("activity", event.currentTarget)
|
|
}
|
|
onPointerEnter={() => preloadWorkspaceRouteOnIntent("activity")}
|
|
type="button"
|
|
>
|
|
<ChartColumn aria-hidden="true" size={17} />
|
|
<span>{t("navigation.activity")}</span>
|
|
</button>
|
|
</nav>
|
|
|
|
<ConversationSidebar
|
|
actions={conversationSidebarActions}
|
|
actionsRef={conversationActionsRef}
|
|
activeConversationIds={activeConversationIds}
|
|
activeId={activeId}
|
|
activeProjectId={activeProjectId}
|
|
activeProjectKind={activeProject?.kind}
|
|
activityByConversationId={activityByConversationId}
|
|
assistantSchedules={assistantSchedules}
|
|
branchingConversationId={branchingConversationId}
|
|
confirmingConversationId={confirmingConversationId}
|
|
conversationActionsId={conversationActionsId}
|
|
conversationStoreReady={conversationStoreReady}
|
|
deletingConversationId={deletingConversationId}
|
|
expandedTaskConversationIds={expandedTaskConversationIds}
|
|
handlers={conversationListRowHandlers}
|
|
loadError={conversationLoadError}
|
|
locale={locale}
|
|
pinningConversationId={pinningConversationId}
|
|
queuedConversationIds={queuedConversationIds}
|
|
renamingConversationId={renamingConversationId}
|
|
searchQuery={searchQuery}
|
|
selectedAssistantTaskId={selectedAssistantTaskId}
|
|
sidebarOpen={sidebarOpen}
|
|
store={conversationStore}
|
|
tasksByConversation={tasksByConversation}
|
|
unreadConversationIds={unreadConversationIds}
|
|
/>
|
|
|
|
<div className="sidebar-footer sidebar-footer--applications">
|
|
<button
|
|
className="nav-item"
|
|
type="button"
|
|
ref={applicationMenuTriggerRef}
|
|
aria-haspopup="menu"
|
|
aria-expanded={applicationMenuOpen}
|
|
aria-controls="application-menu"
|
|
onKeyDown={(event) => {
|
|
if (event.key !== 'ArrowDown' && event.key !== 'ArrowUp') return;
|
|
event.preventDefault();
|
|
if (!applicationMenuOpen) {
|
|
setApplicationMenuOpen(true);
|
|
void reloadApplicationSettings();
|
|
}
|
|
}}
|
|
onClick={() => {
|
|
setApplicationMenuOpen(!applicationMenuOpen);
|
|
if (!applicationMenuOpen) void reloadApplicationSettings();
|
|
}}
|
|
>
|
|
<Grid2X2 size={17} aria-hidden="true" />
|
|
<span>{t("applications.menuLabel")}</span>
|
|
<ChevronUp size={16} aria-hidden="true" />
|
|
</button>
|
|
<div className="sidebar-footer__divider" aria-hidden="true" />
|
|
<button
|
|
className="nav-item"
|
|
aria-label={t('navigation.settings')}
|
|
title={t('navigation.settings')}
|
|
type="button"
|
|
onFocus={() => preloadWorkspaceRouteOnIntent("settings")}
|
|
onClick={(event) =>
|
|
navigateFromSidebar("settings", event.currentTarget)
|
|
}
|
|
onPointerEnter={() => preloadWorkspaceRouteOnIntent("settings")}
|
|
>
|
|
<Settings size={16} aria-hidden="true" />
|
|
<span>{t('navigation.settings')}</span>
|
|
</button>
|
|
</div>
|
|
</aside>
|
|
{sidebarOpen && (
|
|
<div
|
|
aria-controls="primary-sidebar"
|
|
aria-disabled={!canResizePrimarySidebar}
|
|
aria-label={t("sidebar.resizeAriaLabel")}
|
|
aria-orientation="vertical"
|
|
aria-valuemax={primarySidebarWidthLimits.maximum}
|
|
aria-valuemin={primarySidebarWidthLimits.minimum}
|
|
aria-valuenow={primarySidebarWidth}
|
|
aria-valuetext={t("sidebar.resizeValue", {
|
|
width: primarySidebarWidth,
|
|
})}
|
|
className="primary-sidebar-resize-handle"
|
|
onKeyDown={resizePrimarySidebarWithKeyboard}
|
|
onLostPointerCapture={(event) => {
|
|
if (primarySidebarResizePointerIdRef.current === event.pointerId) {
|
|
primarySidebarResizePointerIdRef.current = undefined;
|
|
setPrimarySidebarWidth(livePrimarySidebarWidthRef.current);
|
|
setPrimarySidebarResizing(false);
|
|
}
|
|
}}
|
|
onPointerCancel={finishPrimarySidebarResize}
|
|
onPointerDown={(event) => {
|
|
if (event.button !== 0 || !canResizePrimarySidebar) {
|
|
return;
|
|
}
|
|
event.preventDefault();
|
|
primarySidebarResizePointerIdRef.current = event.pointerId;
|
|
event.currentTarget.setPointerCapture(event.pointerId);
|
|
resizePrimarySidebarFromClientX(event.clientX, true);
|
|
setPrimarySidebarResizing(true);
|
|
}}
|
|
onPointerMove={(event) => {
|
|
if (primarySidebarResizePointerIdRef.current !== event.pointerId) {
|
|
return;
|
|
}
|
|
if (!canResizePrimarySidebar) {
|
|
finishPrimarySidebarResize(event);
|
|
return;
|
|
}
|
|
event.preventDefault();
|
|
resizePrimarySidebarFromClientX(event.clientX, false);
|
|
}}
|
|
onPointerUp={finishPrimarySidebarResize}
|
|
role="separator"
|
|
tabIndex={canResizePrimarySidebar ? 0 : -1}
|
|
/>
|
|
)}
|
|
{sidebarOpen && (
|
|
<button
|
|
aria-label={t("sidebar.close")}
|
|
className="sidebar-backdrop"
|
|
onClick={closeNarrowSidebar}
|
|
type="button"
|
|
/>
|
|
)}
|
|
|
|
<div className="app-frame">
|
|
<header className="topbar">
|
|
<button
|
|
className="icon-button sidebar-toggle"
|
|
type="button"
|
|
aria-label={t("sidebar.toggle")}
|
|
onClick={() => setSidebarOpen((open) => !open)}
|
|
ref={sidebarToggleRef}
|
|
>
|
|
<PanelLeft aria-hidden="true" size={18} />
|
|
</button>
|
|
{view === "chat" && (
|
|
<>
|
|
<div
|
|
className="conversation-title"
|
|
title={activeConversation?.title}
|
|
>
|
|
<span className="conversation-title__text">
|
|
{activeConversation
|
|
? activeConversation.unused
|
|
? t("conversation.defaultTitle")
|
|
: activeConversation.title
|
|
: activeProject?.kind === "channel"
|
|
? t("conversation.remoteTitle")
|
|
: t("conversation.defaultTitle")}
|
|
</span>
|
|
{activeConversation?.branch && (
|
|
<ConversationBranchBadge
|
|
sourceTitle={
|
|
conversationTitles.get(
|
|
activeConversation.branch.sourceConversationId,
|
|
) ?? activeConversation.branch.sourceTitle
|
|
}
|
|
/>
|
|
)}
|
|
{activeConversation?.remote && (
|
|
<b className="conversation-source-badge">
|
|
{projectChannelLabels[activeConversation.remote.channel]}
|
|
</b>
|
|
)}
|
|
</div>
|
|
{magicNotesEnabled && activeConversation && <>
|
|
<button type="button" className="icon-button" ref={noteTitleMenuRef} aria-label={t('magicNotes:capture.menu')} title={t('magicNotes:capture.menu')} aria-haspopup="menu" aria-expanded={noteTitleMenuOpen} onClick={() => setNoteTitleMenuOpen(value => !value)}><MoreHorizontal size={16} /></button>
|
|
{noteTitleMenuOpen && <AnchoredMenu anchorRef={noteTitleMenuRef} id="note-conversation-menu" label={t('magicNotes:capture.menu')} onClose={() => setNoteTitleMenuOpen(false)}>
|
|
<button role="menuitem" tabIndex={-1} type="button" disabled={isRunning || noteCaptureLoading || noteDraft.saving} title={isRunning ? t('magicNotes:capture.wait') : undefined} onClick={() => { setNoteTitleMenuOpen(false); void captureToNote(activeConversation.id); }}>{t(noteCaptureLoading ? 'magicNotes:capture.loading' : 'magicNotes:capture.conversation')}</button>
|
|
</AnchoredMenu>}
|
|
</>}
|
|
<ScopeBadge
|
|
scope={
|
|
activeProject
|
|
? {
|
|
kind: "project",
|
|
projectName:
|
|
activeProjectDisplayName ?? activeProject.name,
|
|
}
|
|
: {
|
|
kind: "unavailable",
|
|
explanation: t("notices.projectNotLoaded"),
|
|
}
|
|
}
|
|
/>
|
|
</>
|
|
)}
|
|
<div className="topbar__actions">
|
|
<button
|
|
aria-controls="assistant-sidebar"
|
|
aria-expanded={assistantSidebarOpen}
|
|
aria-label={t("topbar.toggleAssistantSidebar")}
|
|
className="icon-button assistant-sidebar-toggle"
|
|
onClick={() => setAssistantSidebarOpen((current) => !current)}
|
|
ref={assistantSidebarToggleRef}
|
|
title={t("topbar.toggleAssistantSidebar")}
|
|
type="button"
|
|
>
|
|
{assistantSidebarOpen ? (
|
|
<PanelRightClose aria-hidden="true" size={18} />
|
|
) : (
|
|
<PanelRightOpen aria-hidden="true" size={18} />
|
|
)}
|
|
</button>
|
|
<button
|
|
aria-label={
|
|
resolvedAppearanceTheme === "dark"
|
|
? t("topbar.switchLight")
|
|
: t("topbar.switchDark")
|
|
}
|
|
aria-pressed={resolvedAppearanceTheme === "dark"}
|
|
className="icon-button theme-toggle-button"
|
|
onClick={toggleAppearanceTheme}
|
|
title={
|
|
resolvedAppearanceTheme === "dark"
|
|
? t("topbar.switchLight")
|
|
: t("topbar.switchDark")
|
|
}
|
|
type="button"
|
|
>
|
|
{resolvedAppearanceTheme === "dark" ? (
|
|
<Sun aria-hidden="true" size={18} />
|
|
) : (
|
|
<Moon aria-hidden="true" size={18} />
|
|
)}
|
|
</button>
|
|
</div>
|
|
<WindowControls onError={handleWindowControlError} />
|
|
</header>
|
|
|
|
<div className="app-content">
|
|
<main
|
|
aria-hidden={backgroundIsolated ? "true" : undefined}
|
|
className="workspace"
|
|
inert={backgroundIsolated}
|
|
>
|
|
{(view === "chat" || cachedWorkspaceViewKeys.has("chat")) && (
|
|
<KeepAliveRoute active={view === "chat"} route="chat">
|
|
<PageShell variant="reading">
|
|
<div className="chat-scroll-region">
|
|
{conversationPaneOrder.map((conversationId) => (
|
|
<ConversationHistorySlot
|
|
active={view === "chat" && conversationId === activeId}
|
|
taskStore={taskStore}
|
|
conversationHtmlRenderingEnabled={
|
|
conversationHtmlRenderingEnabled
|
|
}
|
|
conversationId={conversationId}
|
|
key={conversationId}
|
|
loadHistory={ensureConversationHistory}
|
|
locale={locale}
|
|
onCopyMessage={copyMessage}
|
|
onAddToNote={magicNotesEnabled ? captureToNote : undefined}
|
|
noteMessageNavigation={noteMessageNavigation}
|
|
onDownloadImage={downloadImage}
|
|
onEditImage={editImage}
|
|
onOpenImageModelSettings={openImageModelSettings}
|
|
onReselectImageSources={reselectImageSources}
|
|
onOpenCitationContext={openCitationContext}
|
|
onOpenCitationSource={openCitationSource}
|
|
onOpenImage={openImageViewer}
|
|
onRemoveSchedule={removeAssistantSchedule}
|
|
onRespondQuestion={respondToQuestion}
|
|
onRetry={retryMessage}
|
|
onRunSchedule={runAssistantSchedule}
|
|
onScrollSnapshotChange={handleChatScrollSnapshotChange}
|
|
onSelectTask={setSelectedAssistantTaskId}
|
|
onSetInput={setQuickActionInput}
|
|
onSetScheduleEnabled={setAssistantScheduleEnabled}
|
|
onVisibleMessageCountChange={
|
|
handleVisibleMessageCountChange
|
|
}
|
|
quickActions={quickActions}
|
|
schedules={assistantSchedules}
|
|
scrollSnapshot={chatScrollSnapshots[conversationId]}
|
|
selectedAssistantTaskId={selectedAssistantTaskId}
|
|
store={conversationStore}
|
|
tasks={tasksByConversation.get(conversationId) ?? emptyConversationTasks}
|
|
visibleMessageCount={
|
|
visibleMessageCounts[conversationId] ??
|
|
messageRenderBatchSize
|
|
}
|
|
/>
|
|
))}
|
|
{activeProject?.kind === "channel" &&
|
|
!activeConversation && (
|
|
<section className="chat">
|
|
<EmptyState
|
|
action={
|
|
<button
|
|
className="secondary-button"
|
|
onClick={() => {
|
|
setSettingsInitialCategory("channels");
|
|
setSettingsInitialChannel(
|
|
activeProject.channel,
|
|
);
|
|
setView("settings");
|
|
}}
|
|
type="button"
|
|
>
|
|
{t("chat.remote.openSettings")}
|
|
</button>
|
|
}
|
|
description={t("chat.remote.emptyDescription", {
|
|
project: activeProject.name,
|
|
})}
|
|
icon={<MessageSquare size={28} />}
|
|
level="page"
|
|
title={t("conversation.noRemote")}
|
|
/>
|
|
</section>
|
|
)}
|
|
</div>
|
|
|
|
<footer className="composer-wrap">
|
|
{activeProject?.kind === "channel" ? (
|
|
<div className="remote-conversation-notice">
|
|
<MessageSquare aria-hidden="true" size={18} />
|
|
<div>
|
|
<strong>{t("chat.remote.title")}</strong>
|
|
<span>
|
|
{activeConversation?.remote
|
|
? t("chat.remote.continueInClient", {
|
|
client:
|
|
projectChannelLabels[
|
|
activeConversation.remote.channel
|
|
],
|
|
})
|
|
: t("chat.remote.waiting")}
|
|
</span>
|
|
</div>
|
|
</div>
|
|
) : (
|
|
<>
|
|
<Composer
|
|
actions={composerActions}
|
|
activeProjectId={activeProjectId}
|
|
activeRuntimeSelection={activeRuntimeSelection}
|
|
assistantExpertOptions={assistantExpertOptions}
|
|
attachmentButtonRef={attachmentButtonRef}
|
|
attachmentOperations={attachmentOperations}
|
|
attachments={attachments}
|
|
composerDrafts={composerDrafts}
|
|
contextError={contextError}
|
|
conversationHint={composerConversationHint}
|
|
conversationId={activeId}
|
|
conversationStore={conversationStore}
|
|
executionRunning={conversationExecutionRunning}
|
|
externalInstances={externalInstances}
|
|
fileSelectionProgress={fileSelectionProgress}
|
|
imageReferences={imageReferences}
|
|
inputRef={inputRef}
|
|
keyboardHint={composerKeyboardHint}
|
|
knowledgeLibraries={knowledgeSnapshot.libraries}
|
|
menuStore={composerMenus}
|
|
nativeClientAvailable={nativeClientAvailable}
|
|
nativeClientContextKey={nativeClientContextKey}
|
|
projectRecoveryBlocked={activeProjectRecoveryBlocked}
|
|
projectRuntimeSelection={activeProject?.runtimeSelection}
|
|
projectUsesManagedSsh={activeProjectUsesManagedSsh}
|
|
queueItems={activeConversationQueueItems}
|
|
runtime={runtime}
|
|
runtimeActionOptions={runtimeActionOptions}
|
|
runtimeAgentOptions={runtimeAgentOptions}
|
|
runtimeContextCompactAvailable={runtimeContextCompactAvailable}
|
|
runtimeContextCompacting={runtimeContextCompacting}
|
|
runtimeLabel={activeRuntimeLabel}
|
|
runtimeMenuButtonRef={runtimeMenuButtonRef}
|
|
runtimeModelDetail={activeRuntimeModelDetail}
|
|
runtimeNativeSnapshot={runtimeNativeSnapshot}
|
|
runtimePresetOptions={runtimePresetOptions}
|
|
runtimeSettings={runtimeSettings}
|
|
runtimeStatusKey={runtimeStatusKey}
|
|
runtimeSwitching={runtimeSwitching}
|
|
selectedContinuePreset={selectedContinuePreset}
|
|
selectedExpertId={selectedExpertId}
|
|
selectedRuntimeAgent={selectedRuntimeAgent}
|
|
selectedRuntimeCommand={selectedRuntimeCommand}
|
|
selectingContextFiles={selectingContextFiles}
|
|
supervisorEnabled={applicationSettings?.heartbeatEnabled === true}
|
|
updateAttachmentBusy={updateAttachmentBusy}
|
|
voiceListening={voiceListening}
|
|
voiceRecording={voiceRecording}
|
|
workspaceView={view}
|
|
/>
|
|
</>
|
|
)}
|
|
</footer>
|
|
</PageShell>
|
|
</KeepAliveRoute>
|
|
)}
|
|
{(view === "magic-notes" ||
|
|
cachedWorkspaceViewKeys.has("magic-notes")) && (
|
|
<KeepAliveRoute
|
|
active={view === "magic-notes"}
|
|
onUnsavedChanges={workspaceUnsavedChangesReporters["magic-notes"]}
|
|
route="magic-notes"
|
|
>
|
|
<ApplicationAvailability enabled={magicNotesEnabled}>
|
|
<PageShell variant="master-detail">
|
|
<RouteErrorBoundary
|
|
key="magic-notes"
|
|
fallback={
|
|
<RouteLoadError
|
|
message={t("route.loadFailed")}
|
|
reloadLabel={t("route.reload")}
|
|
/>
|
|
}
|
|
>
|
|
<Suspense
|
|
fallback={
|
|
<RouteLoadingStatus label={t("route.loading")} />
|
|
}
|
|
>
|
|
<MagicNotesWorkspace onNotify={notify} applicationSettings={applicationSettings} onBeforeLeave={registerNotesLeaveRequester} navigation={notesNavigation} onOpenSource={magicNotesActions.onOpenSource} />
|
|
</Suspense>
|
|
</RouteErrorBoundary>
|
|
</PageShell>
|
|
</ApplicationAvailability>
|
|
</KeepAliveRoute>
|
|
)}
|
|
{(view === "knowledge" ||
|
|
cachedWorkspaceViewKeys.has("knowledge")) && (
|
|
<KeepAliveRoute
|
|
active={view === "knowledge"}
|
|
onUnsavedChanges={workspaceUnsavedChangesReporters.knowledge}
|
|
route="knowledge"
|
|
>
|
|
<PageShell variant="master-detail">
|
|
<RouteErrorBoundary
|
|
key="knowledge"
|
|
fallback={
|
|
<RouteLoadError
|
|
message={t("route.loadFailed")}
|
|
reloadLabel={t("route.reload")}
|
|
/>
|
|
}
|
|
>
|
|
<Suspense
|
|
fallback={
|
|
<RouteLoadingStatus label={t("route.loading")} />
|
|
}
|
|
>
|
|
<KnowledgeWorkspace
|
|
{...knowledgeWorkspaceActions}
|
|
externalInstances={externalInstances}
|
|
documents={knowledgeSnapshot.documents}
|
|
evidence={knowledgeSnapshot.evidence}
|
|
graphNodes={knowledgeSnapshot.graphNodes}
|
|
graphRelations={knowledgeSnapshot.graphRelations}
|
|
libraries={knowledgeSnapshot.libraries}
|
|
loadError={knowledgeLoadError}
|
|
loading={knowledgeLoading}
|
|
selectedLibraryId={knowledgeSnapshot.selectedLibraryId}
|
|
sources={knowledgeSnapshot.sources}
|
|
tasks={knowledgeSnapshot.tasks}
|
|
/>
|
|
</Suspense>
|
|
</RouteErrorBoundary>
|
|
</PageShell>
|
|
</KeepAliveRoute>
|
|
)}
|
|
{(view === "heartbeat" ||
|
|
cachedWorkspaceViewKeys.has("heartbeat")) && (
|
|
<KeepAliveRoute
|
|
active={view === "heartbeat"}
|
|
onUnsavedChanges={workspaceUnsavedChangesReporters.heartbeat}
|
|
route="heartbeat"
|
|
>
|
|
<PageShell variant="supervisor">
|
|
<RouteErrorBoundary
|
|
key="heartbeat"
|
|
fallback={
|
|
<RouteLoadError
|
|
message={t("route.loadFailed")}
|
|
reloadLabel={t("route.reload")}
|
|
/>
|
|
}
|
|
>
|
|
<Suspense
|
|
fallback={
|
|
<RouteLoadingStatus label={t("route.loading")} />
|
|
}
|
|
>
|
|
{isApplicationEnabled(applicationSettings, 'heartbeat') ? <HeartbeatCenter
|
|
onNotify={notify}
|
|
runtimeSettings={runtimeSettings}
|
|
applicationSettings={applicationSettings}
|
|
applicationSettingsPending={applicationSettingsPending}
|
|
applicationSettingsLocked={applicationSettingsUnconfirmed}
|
|
applicationSettingsError={applicationSettingsError}
|
|
onUpdateApplicationSettings={updateApplicationSettings}
|
|
onRetryApplicationSettings={heartbeatActions.onRetryApplicationSettings}
|
|
active={view === 'heartbeat'}
|
|
graphNavigation={supervisionGraphNavigation}
|
|
onOpenConversation={openActivityConversation}
|
|
configs={assistantHeartbeats}
|
|
entries={heartbeatEntries}
|
|
loadError={heartbeatLoadError}
|
|
loading={heartbeatLoading}
|
|
memories={heartbeatMemories}
|
|
onCreate={createHeartbeat}
|
|
onRefresh={retryHeartbeatLoad}
|
|
onRetryLoad={retryHeartbeatLoad}
|
|
onRemove={removeHeartbeat}
|
|
onRunNow={runHeartbeat}
|
|
onSetMemoryStatus={heartbeatActions.onSetMemoryStatus}
|
|
onSetPaused={setHeartbeatPaused}
|
|
onSetTaskStatus={heartbeatActions.onSetTaskStatus}
|
|
onUpdate={updateHeartbeat}
|
|
onUseFollowUpTask={heartbeatActions.onUseFollowUpTask}
|
|
projects={projects}
|
|
runs={heartbeatRuns}
|
|
tasks={heartbeatTasks}
|
|
/> : <p role="status">{t('applications.disabledPage')}</p>}
|
|
</Suspense>
|
|
</RouteErrorBoundary>
|
|
</PageShell>
|
|
</KeepAliveRoute>
|
|
)}
|
|
{view === 'device-sharing' && isApplicationEnabled(applicationSettings, 'device-sharing') && <DeviceSharingPage notify={notify} />}
|
|
{localInferenceOpen && (
|
|
<LocalInferencePage
|
|
enabled={isApplicationEnabled(applicationSettings, "local-inference")}
|
|
onClose={() => setLocalInferenceOpen(false)}
|
|
restoreFocus={() => applicationMenuTriggerRef.current?.closest('[aria-hidden="true"]')
|
|
? document.querySelector<HTMLElement>('.sidebar-toggle')
|
|
: applicationMenuTriggerRef.current}
|
|
/>
|
|
)}
|
|
{applicationCenterOpen && (
|
|
<ApplicationCenter
|
|
settings={applicationSettings}
|
|
pending={applicationSettingsPending}
|
|
locked={applicationSettingsUnconfirmed}
|
|
error={applicationSettingsError}
|
|
onClose={() => setApplicationCenterOpen(false)}
|
|
onOpen={(id) => {
|
|
if (!isApplicationEnabled(applicationSettings, id)) return;
|
|
setApplicationCenterOpen(false);
|
|
setView(id);
|
|
if (window.innerWidth < 900) setSidebarOpen(false);
|
|
}}
|
|
onUpdate={updateApplicationSettings}
|
|
onRetry={() => void reloadApplicationSettings()}
|
|
/>
|
|
)}
|
|
{applicationMenuOpen && (
|
|
<ApplicationMenu
|
|
anchorRef={applicationMenuTriggerRef}
|
|
settings={applicationSettings}
|
|
pending={applicationSettingsPending || (!applicationSettings && !applicationSettingsError)}
|
|
error={applicationSettingsError}
|
|
onClose={() => setApplicationMenuOpen(false)}
|
|
onOpen={(id) => {
|
|
setView(id);
|
|
if (window.innerWidth < 900) setSidebarOpen(false);
|
|
}}
|
|
onManage={() => {
|
|
setApplicationCenterOpen(true);
|
|
}}
|
|
onRetry={() => void reloadApplicationSettings()}
|
|
/>
|
|
)}
|
|
{settingsOpen && (
|
|
<RouteErrorBoundary
|
|
key="settings"
|
|
fallback={
|
|
<RouteLoadError
|
|
message={t("route.loadFailed")}
|
|
reloadLabel={t("route.reload")}
|
|
/>
|
|
}
|
|
>
|
|
<Suspense fallback={null}>
|
|
<SettingsPanel
|
|
{...settingsPanelActions}
|
|
appearanceTheme={appearanceTheme}
|
|
transparentFrostedEffectEnabled={applicationSettings?.transparentFrostedEffectEnabled ?? true}
|
|
applicationSettingsPending={applicationSettingsPending}
|
|
applicationSettingsLocked={applicationSettingsUnconfirmed || !applicationSettings}
|
|
applicationSettingsError={applicationSettingsError}
|
|
brandingFallbackLogo={
|
|
resolvedAppearanceTheme === "dark"
|
|
? goodbuddyDarkIcon
|
|
: goodbuddyLightIcon
|
|
}
|
|
brandingPreferences={brandingPreferences}
|
|
initialCategory={settingsInitialCategory}
|
|
initialChannel={settingsInitialChannel}
|
|
magicNotesEnabled={magicNotesEnabled}
|
|
remoteProjectsEnabled={remoteProjectsEnabled}
|
|
onConversationHtmlRenderingEnabledChange={
|
|
setConversationHtmlRenderingEnabled
|
|
}
|
|
onAppearanceThemeChange={setAppearanceTheme}
|
|
onNotify={notify}
|
|
onLeaveRequestReady={registerSettingsLeaveRequester}
|
|
onShortcutSettingsChanged={handleShortcutSettingsChanged}
|
|
open={settingsOpen}
|
|
projects={projects}
|
|
/>
|
|
</Suspense>
|
|
</RouteErrorBoundary>
|
|
)}
|
|
{(view === "activity" ||
|
|
cachedWorkspaceViewKeys.has("activity")) && (
|
|
<KeepAliveRoute
|
|
active={view === "activity"}
|
|
onUnsavedChanges={workspaceUnsavedChangesReporters.activity}
|
|
route="activity"
|
|
>
|
|
<PageShell variant="dashboard">
|
|
<RouteErrorBoundary
|
|
key="activity"
|
|
fallback={
|
|
<RouteLoadError
|
|
message={t("route.loadFailed")}
|
|
reloadLabel={t("route.reload")}
|
|
/>
|
|
}
|
|
>
|
|
<Suspense
|
|
fallback={
|
|
<RouteLoadingStatus label={t("route.loading")} />
|
|
}
|
|
>
|
|
<ActivityPanel
|
|
onClear={clearActivity}
|
|
onOpenConversation={openActivityConversation}
|
|
onRefresh={manualRefreshActivity}
|
|
projects={projects}
|
|
paging={activityPaging}
|
|
records={activityPanel.page.records}
|
|
tokenUsage={tokenUsage}
|
|
/>
|
|
</Suspense>
|
|
</RouteErrorBoundary>
|
|
</PageShell>
|
|
</KeepAliveRoute>
|
|
)}
|
|
</main>
|
|
<AppNotificationViewport
|
|
dispatch={notify}
|
|
notifications={notifications}
|
|
/>
|
|
{releaseNotes && (
|
|
<ReleaseNotesDialog
|
|
locale={locale}
|
|
onAcknowledge={async (version) => {
|
|
const releaseNotesApi = window.goodbuddy.releaseNotes;
|
|
if (!releaseNotesApi) {
|
|
throw new Error("Release notes service is unavailable");
|
|
}
|
|
await releaseNotesApi.acknowledge(version);
|
|
}}
|
|
onClose={() => setReleaseNotes(undefined)}
|
|
snapshot={releaseNotes}
|
|
/>
|
|
)}
|
|
{citationDialog && (
|
|
<KnowledgeCitationDialog
|
|
context={citationDialog.context}
|
|
error={citationDialog.error}
|
|
loading={citationDialog.loading}
|
|
onClose={() => { citationRequestRef.current++; setCitationDialog(undefined); }}
|
|
onOpenSource={async () => {
|
|
const { reference } = citationDialog;
|
|
if (reference.external || !reference.chunkId || !reference.documentId) {
|
|
throw new Error(t("chat.citations.contextUnavailable"));
|
|
}
|
|
await window.goodbuddy.knowledge.openReferenceSource({
|
|
knowledgeBaseId: reference.libraryId,
|
|
documentId: reference.documentId,
|
|
chunkId: reference.chunkId,
|
|
});
|
|
}}
|
|
reference={citationDialog.reference}
|
|
/>
|
|
)}
|
|
{imageViewerItem && createPortal(
|
|
<div
|
|
className="image-viewer-backdrop"
|
|
onMouseDown={(event) => {
|
|
if (event.target === event.currentTarget) {
|
|
closeImageViewer();
|
|
}
|
|
}}
|
|
>
|
|
<section
|
|
aria-labelledby="image-viewer-title"
|
|
aria-modal="true"
|
|
className="image-viewer-dialog"
|
|
onKeyDown={(event) => {
|
|
if (event.key === "Escape") {
|
|
event.preventDefault();
|
|
closeImageViewer();
|
|
return;
|
|
}
|
|
trapTabFocus(event, imageViewerDialogRef.current);
|
|
}}
|
|
ref={imageViewerDialogRef}
|
|
role="dialog"
|
|
>
|
|
<header className="image-viewer-dialog__header">
|
|
<strong id="image-viewer-title">
|
|
{imageViewerItem.title}
|
|
</strong>
|
|
<div>
|
|
<button
|
|
aria-label={t("chat.images.downloadImage")}
|
|
className="icon-button attachment-action"
|
|
title={t("chat.images.downloadImage")}
|
|
data-tooltip={t("chat.images.downloadImage")}
|
|
onClick={() => downloadImage(imageViewerItem)}
|
|
type="button"
|
|
>
|
|
<Download size={16} aria-hidden="true" />
|
|
</button>
|
|
<button
|
|
aria-label={t("chat.images.closeViewer")}
|
|
className="icon-button"
|
|
onClick={closeImageViewer}
|
|
ref={imageViewerCloseRef}
|
|
type="button"
|
|
>
|
|
<X size={16} />
|
|
</button>
|
|
</div>
|
|
</header>
|
|
<div className="image-viewer-dialog__content">
|
|
<img alt={imageViewerItem.title} src={imageViewerItem.src} />
|
|
</div>
|
|
</section>
|
|
</div>,
|
|
document.body
|
|
)}
|
|
{customTaskDialog && activeProject?.kind === "user" && (
|
|
<ConversationListView store={conversationStore}>{(conversations) => (
|
|
<CustomTaskDialog
|
|
conversations={conversations.filter(
|
|
(conversation) => !conversation.remote &&
|
|
conversation.projectId === activeProject.id,
|
|
)}
|
|
currentConversationAvailable={Boolean(
|
|
activeConversation &&
|
|
!activeConversation.remote &&
|
|
activeConversation.projectId === activeProject.id,
|
|
)}
|
|
currentConversationId={activeConversation?.id}
|
|
defaultDestination={customTaskDialog.defaultDestination}
|
|
onClose={() => setCustomTaskDialog(undefined)}
|
|
onCreate={createCustomTask}
|
|
projectId={activeProject.id}
|
|
projectName={activeProjectDisplayName ?? activeProject.name}
|
|
workspaceLabel={
|
|
activeProject.rootPath || t("customTask.scope.noWorkspace")
|
|
}
|
|
/>
|
|
)}</ConversationListView>
|
|
)}
|
|
<RightAssistantSidebar
|
|
notify={notify}
|
|
{...rightSidebarActions}
|
|
notesEnabled={magicNotesEnabled}
|
|
notesSettingsReady={Boolean(applicationSettings)}
|
|
notesOpenRequest={notesOpenRequest}
|
|
notesPanel={notesPanel}
|
|
nativeTerminals={nativeTerminals}
|
|
activeConversationId={activeId}
|
|
conversationStats={conversationStats}
|
|
taskDurations={taskDurations}
|
|
approvals={pendingSidebarApprovals}
|
|
browserStates={browserStates}
|
|
conversationTitles={conversationTitles}
|
|
currentProject={activeProject}
|
|
supervisionEnabled={isApplicationEnabled(applicationSettings, 'heartbeat')}
|
|
supervisionLibraries={knowledgeSnapshot.libraries}
|
|
onOpenSupervisionConversation={openActivityConversation}
|
|
schedules={assistantSchedules}
|
|
selectedTaskId={selectedAssistantTaskId}
|
|
tasks={productAssistantTasks}
|
|
projectNames={projectNames}
|
|
onRemoveSchedule={removeAssistantSchedule}
|
|
onRunSchedule={runAssistantSchedule}
|
|
onSetScheduleEnabled={setAssistantScheduleEnabled}
|
|
onListWorkspaceDirectory={listWorkspaceDirectory}
|
|
onLoadWorkspaceFile={loadWorkspaceFile}
|
|
onOpenWorkspaceEntry={openWorkspaceEntry}
|
|
onLoadWorkspaceDiff={loadWorkspaceDiff}
|
|
onRefreshChanges={refreshWorkspaceChanges}
|
|
onTabChange={setAssistantSidebarTab}
|
|
open={assistantSidebarOpen}
|
|
restoreFocusRef={assistantSidebarToggleRef}
|
|
tab={assistantSidebarTab}
|
|
workspaceChanges={activeWorkspaceChanges}
|
|
workspaceProjectId={activeProjectId || undefined}
|
|
/>
|
|
</div>
|
|
</div>
|
|
{noteDraft.confirmation}
|
|
</DocumentConversationContext>
|
|
</LiveMessageStoreContext>
|
|
</div>
|
|
);
|
|
}
|
|
|
|
export default App;
|