diff --git a/app/src/pages/Mnemonic.tsx b/app/src/pages/Mnemonic.tsx index 1946f9fc3..b147c2cd3 100644 --- a/app/src/pages/Mnemonic.tsx +++ b/app/src/pages/Mnemonic.tsx @@ -3,8 +3,7 @@ import { useNavigate } from 'react-router-dom'; import LottieAnimation from '../components/LottieAnimation'; import { skillManager } from '../lib/skills/manager'; -import { setEncryptionKeyForUser } from '../store/authSlice'; -import { useAppDispatch, useAppSelector } from '../store/hooks'; +import { useCoreState } from '../providers/CoreStateProvider'; import { deriveAesKeyFromMnemonic, deriveEvmAddressFromMnemonic, @@ -20,8 +19,8 @@ const IMPORT_SLOTS_INITIAL = MNEMONIC_GENERATE_WORD_COUNT; const Mnemonic = () => { const navigate = useNavigate(); - const dispatch = useAppDispatch(); - const user = useAppSelector(state => state.user.user); + const { snapshot, setEncryptionKey } = useCoreState(); + const user = snapshot.currentUser; const [mode, setMode] = useState<'generate' | 'import'>('generate'); const [copied, setCopied] = useState(false); const [confirmed, setConfirmed] = useState(false); @@ -167,7 +166,7 @@ const Mnemonic = () => { console.error('[Mnemonic] Cannot save encryption key: user not loaded'); return; } - dispatch(setEncryptionKeyForUser({ userId: user._id, key: aesKey })); + await setEncryptionKey(aesKey); await skillManager.setWalletAddress(walletAddress); navigate('/home'); } catch (e) { diff --git a/app/src/pages/onboarding/Onboarding.tsx b/app/src/pages/onboarding/Onboarding.tsx index d571874f7..c349a49fb 100644 --- a/app/src/pages/onboarding/Onboarding.tsx +++ b/app/src/pages/onboarding/Onboarding.tsx @@ -2,12 +2,9 @@ import { useCallback, useEffect, useRef, useState } from 'react'; import { createPortal } from 'react-dom'; import ProgressIndicator from '../../components/ProgressIndicator'; -import { useUser } from '../../hooks/useUser'; +import { useCoreState } from '../../providers/CoreStateProvider'; import { userApi } from '../../services/api/userApi'; -import { setOnboardedForUser, setOnboardingTasksForUser } from '../../store/authSlice'; -import { useAppDispatch } from '../../store/hooks'; import { bootstrapLocalAiWithRecommendedPreset } from '../../utils/localAiBootstrap'; -import { setOnboardingCompleted } from '../../utils/tauriCommands'; import LocalAIStep from './steps/LocalAIStep'; import ScreenPermissionsStep from './steps/ScreenPermissionsStep'; import SkillsStep from './steps/SkillsStep'; @@ -30,8 +27,7 @@ interface OnboardingDraft { const LOCAL_AI_ERROR_DISMISS_MS = 10_000; const Onboarding = ({ onComplete, onDefer }: OnboardingProps) => { - const dispatch = useAppDispatch(); - const { user } = useUser(); + const { setOnboardingCompletedFlag, setOnboardingTasks } = useCoreState(); const [currentStep, setCurrentStep] = useState(0); const [downloadError, setDownloadError] = useState(null); const retryInFlightRef = useRef(false); @@ -108,21 +104,14 @@ const Onboarding = ({ onComplete, onDefer }: OnboardingProps) => { const handleSkillsNext = async (connectedSources: string[]) => { setDraft(prev => ({ ...prev, connectedSources })); - // Persist onboarding tasks - if (user?._id) { - dispatch( - setOnboardingTasksForUser({ - userId: user._id, - tasks: { - accessibilityPermissionGranted: draft.accessibilityPermissionGranted, - localModelConsentGiven: draft.localModelConsentGiven, - localModelDownloadStarted: draft.localModelDownloadStarted, - enabledTools: draft.enabledTools, - connectedSources, - }, - }) - ); - } + await setOnboardingTasks({ + accessibilityPermissionGranted: draft.accessibilityPermissionGranted, + localModelConsentGiven: draft.localModelConsentGiven, + localModelDownloadStarted: draft.localModelDownloadStarted, + enabledTools: draft.enabledTools, + connectedSources, + updatedAtMs: Date.now(), + }); // Notify backend (best-effort — don't block onboarding completion) try { @@ -131,14 +120,9 @@ const Onboarding = ({ onComplete, onDefer }: OnboardingProps) => { console.warn('[onboarding] Failed to notify backend of onboarding completion'); } - // Mark onboarded in Redux (belt-and-suspenders alongside config) - if (user?._id) { - dispatch(setOnboardedForUser({ userId: user._id, value: true })); - } - // Write onboarding_completed to core config (source of truth) try { - await setOnboardingCompleted(true); + await setOnboardingCompletedFlag(true); } catch { console.warn('[onboarding] Failed to persist onboarding_completed to core config'); } diff --git a/app/src/pages/onboarding/steps/MnemonicStep.tsx b/app/src/pages/onboarding/steps/MnemonicStep.tsx index b74048531..0af6f0407 100644 --- a/app/src/pages/onboarding/steps/MnemonicStep.tsx +++ b/app/src/pages/onboarding/steps/MnemonicStep.tsx @@ -1,8 +1,7 @@ import { type KeyboardEvent, useCallback, useEffect, useMemo, useRef, useState } from 'react'; import { skillManager } from '../../../lib/skills/manager'; -import { setEncryptionKeyForUser } from '../../../store/authSlice'; -import { useAppDispatch, useAppSelector } from '../../../store/hooks'; +import { useCoreState } from '../../../providers/CoreStateProvider'; import { deriveAesKeyFromMnemonic, deriveEvmAddressFromMnemonic, @@ -22,8 +21,8 @@ interface MnemonicStepProps { } const MnemonicStep = ({ onNext, onBack: _onBack }: MnemonicStepProps) => { - const dispatch = useAppDispatch(); - const user = useAppSelector(state => state.user.user); + const { snapshot, setEncryptionKey } = useCoreState(); + const user = snapshot.currentUser; const [mode, setMode] = useState<'generate' | 'import'>('generate'); const [copied, setCopied] = useState(false); const [confirmed, setConfirmed] = useState(false); @@ -164,7 +163,7 @@ const MnemonicStep = ({ onNext, onBack: _onBack }: MnemonicStepProps) => { setError('User not loaded. Please sign in again or refresh the page.'); return; } - dispatch(setEncryptionKeyForUser({ userId: user._id, key: aesKey })); + await setEncryptionKey(aesKey); await skillManager.setWalletAddress(walletAddress); await onNext(); } catch (e) { diff --git a/app/src/providers/CoreStateProvider.tsx b/app/src/providers/CoreStateProvider.tsx new file mode 100644 index 000000000..72c5262de --- /dev/null +++ b/app/src/providers/CoreStateProvider.tsx @@ -0,0 +1,300 @@ +import { + createContext, + type ReactNode, + useCallback, + useContext, + useEffect, + useMemo, + useRef, + useState, +} from 'react'; + +import { + type CoreAppSnapshot, + type CoreOnboardingTasks, + type CoreState, + getCoreStateSnapshot, + setCoreStateSnapshot, +} from '../lib/coreState/store'; +import { syncAnalyticsConsent } from '../services/analytics'; +import { + fetchCoreAppSnapshot, + getTeamInvites, + getTeamMembers, + listTeams, + updateCoreLocalState, +} from '../services/coreStateApi'; +import { + openhumanUpdateAnalyticsSettings, + setOnboardingCompleted, + storeSession, + syncMemoryClientToken, + logout as tauriLogout, +} from '../utils/tauriCommands'; + +const POLL_MS = 3000; + +interface CoreStateContextValue extends CoreState { + refresh: () => Promise; + refreshTeams: () => Promise; + refreshTeamMembers: (teamId: string) => Promise; + refreshTeamInvites: (teamId: string) => Promise; + setAnalyticsEnabled: (enabled: boolean) => Promise; + setOnboardingCompletedFlag: (value: boolean) => Promise; + setEncryptionKey: (value: string | null) => Promise; + setPrimaryWalletAddress: (value: string | null) => Promise; + setOnboardingTasks: (value: CoreOnboardingTasks | null) => Promise; + storeSessionToken: (token: string, user?: object) => Promise; + clearSession: () => Promise; +} + +const CoreStateContext = createContext(null); + +function snapshotIdentity(snapshot: CoreAppSnapshot): string | null { + return snapshot.auth.userId ?? snapshot.currentUser?._id ?? null; +} + +function normalizeSnapshot( + result: Awaited> +): CoreAppSnapshot { + return { + auth: result.auth, + sessionToken: result.sessionToken, + currentUser: result.currentUser, + onboardingCompleted: result.onboardingCompleted, + analyticsEnabled: result.analyticsEnabled, + localState: { + encryptionKey: result.localState.encryptionKey ?? null, + primaryWalletAddress: result.localState.primaryWalletAddress ?? null, + onboardingTasks: result.localState.onboardingTasks ?? null, + }, + }; +} + +export default function CoreStateProvider({ children }: { children: ReactNode }) { + const [state, setState] = useState(() => getCoreStateSnapshot()); + const snapshotRequestIdRef = useRef(0); + const teamsRequestIdRef = useRef(0); + const memoryTokenRef = useRef(state.snapshot.sessionToken); + + const commitState = useCallback((updater: (previous: CoreState) => CoreState) => { + setState(previous => { + const next = updater(previous); + setCoreStateSnapshot(next); + return next; + }); + }, []); + + const refresh = useCallback(async () => { + const requestId = ++snapshotRequestIdRef.current; + const snapshot = normalizeSnapshot(await fetchCoreAppSnapshot()); + commitState(previous => { + if (requestId !== snapshotRequestIdRef.current) { + return previous; + } + + const previousIdentity = snapshotIdentity(previous.snapshot); + const nextIdentity = snapshotIdentity(snapshot); + const shouldClearScopedCaches = + previousIdentity !== nextIdentity || + (previous.snapshot.auth.isAuthenticated && !snapshot.auth.isAuthenticated); + + return { + ...previous, + isBootstrapping: false, + isReady: true, + snapshot, + teams: shouldClearScopedCaches ? [] : previous.teams, + teamMembersById: shouldClearScopedCaches ? {} : previous.teamMembersById, + teamInvitesById: shouldClearScopedCaches ? {} : previous.teamInvitesById, + }; + }); + syncAnalyticsConsent(snapshot.analyticsEnabled); + + if (!snapshot.sessionToken) { + memoryTokenRef.current = null; + return; + } + + if (memoryTokenRef.current !== snapshot.sessionToken) { + try { + await syncMemoryClientToken(snapshot.sessionToken); + memoryTokenRef.current = snapshot.sessionToken; + } catch (error) { + console.warn('[core-state] memory client sync failed during refresh:', error); + } + } + }, [commitState]); + + const refreshTeams = useCallback(async () => { + const requestId = ++teamsRequestIdRef.current; + const identityAtStart = snapshotIdentity(getCoreStateSnapshot().snapshot); + const teams = await listTeams(); + commitState(previous => { + if (requestId !== teamsRequestIdRef.current) { + return previous; + } + + if (snapshotIdentity(previous.snapshot) !== identityAtStart) { + return previous; + } + + return { ...previous, teams }; + }); + }, [commitState]); + + const refreshTeamMembers = useCallback( + async (teamId: string) => { + const members = await getTeamMembers(teamId); + commitState(previous => ({ + ...previous, + teamMembersById: { ...previous.teamMembersById, [teamId]: members }, + })); + }, + [commitState] + ); + + const refreshTeamInvites = useCallback( + async (teamId: string) => { + const invites = await getTeamInvites(teamId); + commitState(previous => ({ + ...previous, + teamInvitesById: { ...previous.teamInvitesById, [teamId]: invites }, + })); + }, + [commitState] + ); + + useEffect(() => { + let cancelled = false; + const load = async () => { + try { + await refresh(); + const next = getCoreStateSnapshot(); + if (next.snapshot.auth.isAuthenticated) { + await refreshTeams().catch(() => {}); + } + } catch (error) { + if (!cancelled) { + console.warn('[core-state] initial refresh failed:', error); + commitState(previous => ({ ...previous, isBootstrapping: false })); + } + } + }; + + void load(); + const interval = window.setInterval(() => { + void refresh().catch(error => { + console.warn('[core-state] poll failed:', error); + }); + }, POLL_MS); + + return () => { + cancelled = true; + window.clearInterval(interval); + }; + }, [commitState, refresh, refreshTeams]); + + const setAnalyticsEnabled = useCallback( + async (enabled: boolean) => { + await openhumanUpdateAnalyticsSettings({ enabled }); + commitState(previous => ({ + ...previous, + snapshot: { ...previous.snapshot, analyticsEnabled: enabled }, + })); + syncAnalyticsConsent(enabled); + }, + [commitState] + ); + + const setOnboardingCompletedFlag = useCallback( + async (value: boolean) => { + await setOnboardingCompleted(value); + commitState(previous => ({ + ...previous, + snapshot: { ...previous.snapshot, onboardingCompleted: value }, + })); + }, + [commitState] + ); + + const updateLocalState = useCallback( + async (params: Parameters[0]) => { + await updateCoreLocalState(params); + await refresh(); + }, + [refresh] + ); + + const storeSessionToken = useCallback( + async (token: string, user?: object) => { + await storeSession(token, user ?? {}); + try { + await syncMemoryClientToken(token); + memoryTokenRef.current = token; + } catch (error) { + console.warn('[core-state] memory client sync failed after session store:', error); + } + await refresh(); + await refreshTeams().catch(() => {}); + }, + [refresh, refreshTeams] + ); + + const clearSession = useCallback(async () => { + await tauriLogout(); + commitState(previous => ({ + ...previous, + teams: [], + teamMembersById: {}, + teamInvitesById: {}, + snapshot: { + ...previous.snapshot, + auth: { isAuthenticated: false, userId: null, user: null, profileId: null }, + sessionToken: null, + currentUser: null, + onboardingCompleted: false, + }, + })); + memoryTokenRef.current = null; + }, [commitState]); + + const value = useMemo( + () => ({ + ...state, + refresh, + refreshTeams, + refreshTeamMembers, + refreshTeamInvites, + setAnalyticsEnabled, + setOnboardingCompletedFlag, + setEncryptionKey: value => updateLocalState({ encryptionKey: value }), + setPrimaryWalletAddress: value => updateLocalState({ primaryWalletAddress: value }), + setOnboardingTasks: value => updateLocalState({ onboardingTasks: value }), + storeSessionToken, + clearSession, + }), + [ + clearSession, + refresh, + refreshTeamInvites, + refreshTeamMembers, + refreshTeams, + setAnalyticsEnabled, + setOnboardingCompletedFlag, + state, + storeSessionToken, + updateLocalState, + ] + ); + + return {children}; +} + +export function useCoreState() { + const context = useContext(CoreStateContext); + if (!context) { + throw new Error('useCoreState must be used within CoreStateProvider'); + } + return context; +} diff --git a/app/src/providers/IntelligenceProvider.tsx b/app/src/providers/IntelligenceProvider.tsx deleted file mode 100644 index d0fe454d7..000000000 --- a/app/src/providers/IntelligenceProvider.tsx +++ /dev/null @@ -1,64 +0,0 @@ -import { createContext, type ReactNode, useContext, useEffect } from 'react'; -import { useDispatch } from 'react-redux'; - -import { useIntelligenceSocketManager } from '../hooks/useIntelligenceSocket'; -import { setConnectionStatus, setInitialized } from '../store/intelligenceSlice'; - -/** - * Intelligence context for managing system-wide Intelligence state - */ -interface IntelligenceContextValue { - isInitialized: boolean; - isConnected: boolean; - initialize: () => void; -} - -const IntelligenceContext = createContext(null); - -interface IntelligenceProviderProps { - children: ReactNode; -} - -/** - * Intelligence Provider - manages Intelligence system initialization and state - */ -export function IntelligenceProvider({ children }: IntelligenceProviderProps) { - const dispatch = useDispatch(); - const socketManager = useIntelligenceSocketManager(); - - // Initialize Intelligence system - useEffect(() => { - dispatch(setInitialized(true)); - dispatch(setConnectionStatus(socketManager.isConnected ? 'connected' : 'connecting')); - }, [dispatch, socketManager.isConnected]); - - // Monitor connection status - useEffect(() => { - if (socketManager.isConnected) { - dispatch(setConnectionStatus('connected')); - } else { - dispatch(setConnectionStatus('connecting')); - } - }, [dispatch, socketManager.isConnected]); - - const contextValue: IntelligenceContextValue = { - isInitialized: true, - isConnected: socketManager.isConnected, - initialize: socketManager.connect, - }; - - return ( - {children} - ); -} - -/** - * Hook to access Intelligence context - */ -export function useIntelligenceContext() { - const context = useContext(IntelligenceContext); - if (!context) { - throw new Error('useIntelligenceContext must be used within IntelligenceProvider'); - } - return context; -} diff --git a/app/src/providers/SocketProvider.tsx b/app/src/providers/SocketProvider.tsx index 079f9598c..51075cb98 100644 --- a/app/src/providers/SocketProvider.tsx +++ b/app/src/providers/SocketProvider.tsx @@ -2,9 +2,8 @@ import { useEffect, useRef } from 'react'; import { useDaemonLifecycle } from '../hooks/useDaemonLifecycle'; import { socketService } from '../services/socketService'; -import { store } from '../store'; -import { useAppSelector } from '../store/hooks'; import { IS_DEV } from '../utils/config'; +import { useCoreState } from './CoreStateProvider'; /** * SocketProvider manages the socket connection based on JWT token. @@ -12,7 +11,8 @@ import { IS_DEV } from '../utils/config'; * for both desktop and web. */ const SocketProvider = ({ children }: { children: React.ReactNode }) => { - const token = useAppSelector(state => state.auth.token); + const { snapshot } = useCoreState(); + const token = snapshot.sessionToken; const previousTokenRef = useRef(null); // Keep daemon lifecycle management for desktop health/recovery. @@ -54,12 +54,12 @@ const SocketProvider = ({ children }: { children: React.ReactNode }) => { // Cleanup on unmount only useEffect(() => { return () => { - const currentToken = store.getState().auth.token; + const currentToken = snapshot.sessionToken; if (!currentToken) { socketService.disconnect(); } }; - }, []); + }, [snapshot.sessionToken]); return <>{children}; }; diff --git a/app/src/services/analytics.ts b/app/src/services/analytics.ts index be8dd3992..efcba2add 100644 --- a/app/src/services/analytics.ts +++ b/app/src/services/analytics.ts @@ -20,7 +20,7 @@ */ import * as Sentry from '@sentry/react'; -import { store } from '../store'; +import { getCoreStateSnapshot } from '../lib/coreState/store'; import { IS_DEV, SENTRY_DSN } from '../utils/config'; import { enqueueError, registerSentrySender, type SanitizedSentryEvent } from './errorReportQueue'; @@ -69,10 +69,7 @@ function sanitizeException( /** Check if the current user has opted into analytics. */ export function isAnalyticsEnabled(): boolean { - const state = store.getState(); - const userId = state.user?.user?._id; - if (!userId) return false; - return state.auth.isAnalyticsEnabledByUser[userId] !== false; + return getCoreStateSnapshot().snapshot.analyticsEnabled; } // --------------------------------------------------------------------------- @@ -137,7 +134,7 @@ export function initSentry(): void { delete event.request; // Strip user PII — keep only a stable anonymous ID - const userId = store.getState().user?.user?._id; + const userId = getCoreStateSnapshot().snapshot.currentUser?._id; event.user = userId ? { id: userId } : undefined; // Strip any extra/contexts that could contain Redux or localStorage data diff --git a/app/src/services/api/__tests__/teamApi.test.ts b/app/src/services/api/__tests__/teamApi.test.ts index 57ae76697..86c9b1892 100644 --- a/app/src/services/api/__tests__/teamApi.test.ts +++ b/app/src/services/api/__tests__/teamApi.test.ts @@ -2,105 +2,112 @@ import { beforeEach, describe, expect, it, vi } from 'vitest'; import { teamApi } from '../teamApi'; -// Mock the apiClient module -const mockGet = vi.fn(); -const mockPost = vi.fn(); -const mockPut = vi.fn(); -const mockDelete = vi.fn(); +const mockCallCoreRpc = vi.fn(); -vi.mock('../../apiClient', () => ({ - apiClient: { - get: (...args: unknown[]) => mockGet(...args), - post: (...args: unknown[]) => mockPost(...args), - put: (...args: unknown[]) => mockPut(...args), - delete: (...args: unknown[]) => mockDelete(...args), - }, +vi.mock('../../coreRpcClient', () => ({ + callCoreRpc: (...args: unknown[]) => mockCallCoreRpc(...args), })); describe('teamApi', () => { beforeEach(() => { - mockGet.mockReset(); - mockPost.mockReset(); - mockPut.mockReset(); - mockDelete.mockReset(); + mockCallCoreRpc.mockReset(); }); describe('getTeams', () => { - it('should call GET /teams and return data', async () => { + it('calls team_list_teams and returns the result', async () => { const teams = [{ team: { _id: 't1', name: 'Team 1' }, role: 'ADMIN' }]; - mockGet.mockResolvedValue({ success: true, data: teams }); + mockCallCoreRpc.mockResolvedValue({ result: teams }); const result = await teamApi.getTeams(); - expect(mockGet).toHaveBeenCalledWith('/teams'); + expect(mockCallCoreRpc).toHaveBeenCalledWith({ + method: 'openhuman.team_list_teams', + params: undefined, + }); expect(result).toEqual(teams); }); - it('should propagate errors', async () => { - mockGet.mockRejectedValue({ success: false, error: 'Unauthorized' }); + it('propagates RPC errors', async () => { + const error = new Error('Unauthorized'); + mockCallCoreRpc.mockRejectedValue(error); - await expect(teamApi.getTeams()).rejects.toEqual({ success: false, error: 'Unauthorized' }); + await expect(teamApi.getTeams()).rejects.toThrow('Unauthorized'); }); }); describe('getTeam', () => { - it('should call GET /teams/:teamId', async () => { + it('calls team_get_team', async () => { const team = { _id: 't1', name: 'Team 1' }; - mockGet.mockResolvedValue({ success: true, data: team }); + mockCallCoreRpc.mockResolvedValue({ result: team }); const result = await teamApi.getTeam('t1'); - expect(mockGet).toHaveBeenCalledWith('/teams/t1'); + expect(mockCallCoreRpc).toHaveBeenCalledWith({ + method: 'openhuman.team_get_team', + params: { teamId: 't1' }, + }); expect(result).toEqual(team); }); }); describe('createTeam', () => { - it('should call POST /teams with name', async () => { + it('calls team_create_team with name', async () => { const team = { _id: 't2', name: 'New Team' }; - mockPost.mockResolvedValue({ success: true, data: team }); + mockCallCoreRpc.mockResolvedValue({ result: team }); const result = await teamApi.createTeam('New Team'); - expect(mockPost).toHaveBeenCalledWith('/teams', { name: 'New Team' }); + expect(mockCallCoreRpc).toHaveBeenCalledWith({ + method: 'openhuman.team_create_team', + params: { name: 'New Team' }, + }); expect(result).toEqual(team); }); }); describe('updateTeam', () => { - it('should call PUT /teams/:teamId with data', async () => { + it('calls team_update_team with data', async () => { const team = { _id: 't1', name: 'Updated' }; - mockPut.mockResolvedValue({ success: true, data: team }); + mockCallCoreRpc.mockResolvedValue({ result: team }); const result = await teamApi.updateTeam('t1', { name: 'Updated' }); - expect(mockPut).toHaveBeenCalledWith('/teams/t1', { name: 'Updated' }); + expect(mockCallCoreRpc).toHaveBeenCalledWith({ + method: 'openhuman.team_update_team', + params: { teamId: 't1', name: 'Updated' }, + }); expect(result).toEqual(team); }); }); describe('deleteTeam', () => { - it('should call DELETE /teams/:teamId', async () => { - mockDelete.mockResolvedValue({ success: true, data: null }); + it('calls team_delete_team', async () => { + mockCallCoreRpc.mockResolvedValue({ result: null }); await teamApi.deleteTeam('t1'); - expect(mockDelete).toHaveBeenCalledWith('/teams/t1'); + expect(mockCallCoreRpc).toHaveBeenCalledWith({ + method: 'openhuman.team_delete_team', + params: { teamId: 't1' }, + }); }); }); describe('switchTeam', () => { - it('should call POST /teams/:teamId/switch', async () => { - mockPost.mockResolvedValue({ success: true, data: null }); + it('calls team_switch_team', async () => { + mockCallCoreRpc.mockResolvedValue({ result: null }); await teamApi.switchTeam('t1'); - expect(mockPost).toHaveBeenCalledWith('/teams/t1/switch'); + expect(mockCallCoreRpc).toHaveBeenCalledWith({ + method: 'openhuman.team_switch_team', + params: { teamId: 't1' }, + }); }); }); describe('getMembers', () => { - it('should call GET /teams/:teamId/members', async () => { + it('calls team_list_members', async () => { const members = [ { _id: 'm1', @@ -109,108 +116,131 @@ describe('teamApi', () => { joinedAt: '2026-01-01', }, ]; - mockGet.mockResolvedValue({ success: true, data: members }); + mockCallCoreRpc.mockResolvedValue({ result: members }); const result = await teamApi.getMembers('t1'); - expect(mockGet).toHaveBeenCalledWith('/teams/t1/members'); + expect(mockCallCoreRpc).toHaveBeenCalledWith({ + method: 'openhuman.team_list_members', + params: { teamId: 't1' }, + }); expect(result).toEqual(members); }); }); describe('removeMember', () => { - it('should call DELETE /teams/:teamId/members/:userId', async () => { - mockDelete.mockResolvedValue({ success: true, data: null }); + it('calls team_remove_member', async () => { + mockCallCoreRpc.mockResolvedValue({ result: null }); await teamApi.removeMember('t1', 'u2'); - expect(mockDelete).toHaveBeenCalledWith('/teams/t1/members/u2'); + expect(mockCallCoreRpc).toHaveBeenCalledWith({ + method: 'openhuman.team_remove_member', + params: { teamId: 't1', userId: 'u2' }, + }); }); }); describe('changeMemberRole', () => { - it('should call PUT /teams/:teamId/members/:userId/role', async () => { - mockPut.mockResolvedValue({ success: true, data: null }); + it('calls team_change_member_role', async () => { + mockCallCoreRpc.mockResolvedValue({ result: null }); await teamApi.changeMemberRole('t1', 'u2', 'BILLING_MANAGER'); - expect(mockPut).toHaveBeenCalledWith('/teams/t1/members/u2/role', { - role: 'BILLING_MANAGER', + expect(mockCallCoreRpc).toHaveBeenCalledWith({ + method: 'openhuman.team_change_member_role', + params: { teamId: 't1', userId: 'u2', role: 'BILLING_MANAGER' }, }); }); }); describe('leaveTeam', () => { - it('should call POST /teams/:teamId/leave', async () => { - mockPost.mockResolvedValue({ success: true, data: null }); + it('calls team_leave_team', async () => { + mockCallCoreRpc.mockResolvedValue({ result: null }); await teamApi.leaveTeam('t1'); - expect(mockPost).toHaveBeenCalledWith('/teams/t1/leave'); + expect(mockCallCoreRpc).toHaveBeenCalledWith({ + method: 'openhuman.team_leave_team', + params: { teamId: 't1' }, + }); }); }); describe('createInvite', () => { - it('should call POST /teams/:teamId/invites without opts', async () => { + it('calls team_create_invite without optional fields by default', async () => { const invite = { _id: 'inv1', code: 'ABC123' }; - mockPost.mockResolvedValue({ success: true, data: invite }); + mockCallCoreRpc.mockResolvedValue({ result: invite }); const result = await teamApi.createInvite('t1'); - expect(mockPost).toHaveBeenCalledWith('/teams/t1/invites', undefined); + expect(mockCallCoreRpc).toHaveBeenCalledWith({ + method: 'openhuman.team_create_invite', + params: { teamId: 't1' }, + }); expect(result).toEqual(invite); }); - it('should pass options when provided', async () => { + it('passes invite options when provided', async () => { const invite = { _id: 'inv2', code: 'XYZ789' }; - mockPost.mockResolvedValue({ success: true, data: invite }); + mockCallCoreRpc.mockResolvedValue({ result: invite }); await teamApi.createInvite('t1', { maxUses: 5, expiresInDays: 7 }); - expect(mockPost).toHaveBeenCalledWith('/teams/t1/invites', { maxUses: 5, expiresInDays: 7 }); + expect(mockCallCoreRpc).toHaveBeenCalledWith({ + method: 'openhuman.team_create_invite', + params: { teamId: 't1', maxUses: 5, expiresInDays: 7 }, + }); }); }); describe('getInvites', () => { - it('should call GET /teams/:teamId/invites', async () => { + it('calls team_list_invites', async () => { const invites = [{ _id: 'inv1', code: 'ABC123' }]; - mockGet.mockResolvedValue({ success: true, data: invites }); + mockCallCoreRpc.mockResolvedValue({ result: invites }); const result = await teamApi.getInvites('t1'); - expect(mockGet).toHaveBeenCalledWith('/teams/t1/invites'); + expect(mockCallCoreRpc).toHaveBeenCalledWith({ + method: 'openhuman.team_list_invites', + params: { teamId: 't1' }, + }); expect(result).toEqual(invites); }); }); describe('revokeInvite', () => { - it('should call DELETE /teams/:teamId/invites/:inviteId', async () => { - mockDelete.mockResolvedValue({ success: true, data: null }); + it('calls team_revoke_invite', async () => { + mockCallCoreRpc.mockResolvedValue({ result: null }); await teamApi.revokeInvite('t1', 'inv1'); - expect(mockDelete).toHaveBeenCalledWith('/teams/t1/invites/inv1'); + expect(mockCallCoreRpc).toHaveBeenCalledWith({ + method: 'openhuman.team_revoke_invite', + params: { teamId: 't1', inviteId: 'inv1' }, + }); }); }); describe('joinTeam', () => { - it('should call POST /teams/join with code in body', async () => { + it('calls team_join_team with code', async () => { const team = { _id: 't3', name: 'Joined Team' }; - mockPost.mockResolvedValue({ success: true, data: team }); + mockCallCoreRpc.mockResolvedValue({ result: team }); const result = await teamApi.joinTeam('ABC123'); - expect(mockPost).toHaveBeenCalledWith('/teams/join', { code: 'ABC123' }); + expect(mockCallCoreRpc).toHaveBeenCalledWith({ + method: 'openhuman.team_join_team', + params: { code: 'ABC123' }, + }); expect(result).toEqual(team); }); - it('should propagate errors for invalid codes', async () => { - mockPost.mockRejectedValue({ success: false, error: 'Invalid invite code' }); + it('propagates errors for invalid codes', async () => { + const error = new Error('Invalid invite code'); + mockCallCoreRpc.mockRejectedValue(error); - await expect(teamApi.joinTeam('INVALID')).rejects.toEqual({ - success: false, - error: 'Invalid invite code', - }); + await expect(teamApi.joinTeam('INVALID')).rejects.toThrow('Invalid invite code'); }); }); }); diff --git a/app/src/services/api/teamApi.ts b/app/src/services/api/teamApi.ts index 754abefb4..145a45485 100644 --- a/app/src/services/api/teamApi.ts +++ b/app/src/services/api/teamApi.ts @@ -1,89 +1,57 @@ -import type { ApiResponse } from '../../types/api'; import type { Team, TeamInvite, TeamMember, TeamRole, TeamWithRole } from '../../types/team'; -import { apiClient } from '../apiClient'; +import { callCoreRpc } from '../coreRpcClient'; + +async function rpcResult(method: string, params?: Record): Promise { + const response = await callCoreRpc<{ result: T }>({ method, params }); + return response.result; +} export const teamApi = { - /** GET /teams — list all teams the user belongs to */ - getTeams: async (): Promise => { - const response = await apiClient.get>('/teams'); - return response.data; - }, + getTeams: async (): Promise => rpcResult('openhuman.team_list_teams'), - /** GET /teams/:teamId */ - getTeam: async (teamId: string): Promise => { - const response = await apiClient.get>(`/teams/${teamId}`); - return response.data; - }, + getTeam: async (teamId: string): Promise => + rpcResult('openhuman.team_get_team', { teamId }), - /** POST /teams — create a new team */ - createTeam: async (name: string): Promise => { - const response = await apiClient.post>('/teams', { name }); - return response.data; - }, + createTeam: async (name: string): Promise => + rpcResult('openhuman.team_create_team', { name }), - /** PUT /teams/:teamId */ - updateTeam: async (teamId: string, data: { name?: string }): Promise => { - const response = await apiClient.put>(`/teams/${teamId}`, data); - return response.data; - }, + updateTeam: async (teamId: string, data: { name?: string }): Promise => + rpcResult('openhuman.team_update_team', { teamId, ...data }), - /** DELETE /teams/:teamId */ deleteTeam: async (teamId: string): Promise => { - await apiClient.delete>(`/teams/${teamId}`); + await rpcResult('openhuman.team_delete_team', { teamId }); }, - /** POST /teams/:teamId/switch — set as active team */ switchTeam: async (teamId: string): Promise => { - await apiClient.post>(`/teams/${teamId}/switch`); + await rpcResult('openhuman.team_switch_team', { teamId }); }, - /** GET /teams/:teamId/members */ - getMembers: async (teamId: string): Promise => { - const response = await apiClient.get>(`/teams/${teamId}/members`); - return response.data; - }, + getMembers: async (teamId: string): Promise => + rpcResult('openhuman.team_list_members', { teamId }), - /** DELETE /teams/:teamId/members/:userId */ removeMember: async (teamId: string, userId: string): Promise => { - await apiClient.delete>(`/teams/${teamId}/members/${userId}`); + await rpcResult('openhuman.team_remove_member', { teamId, userId }); }, - /** PUT /teams/:teamId/members/:userId/role */ changeMemberRole: async (teamId: string, userId: string, role: TeamRole): Promise => { - await apiClient.put>(`/teams/${teamId}/members/${userId}/role`, { role }); + await rpcResult('openhuman.team_change_member_role', { teamId, userId, role }); }, - /** POST /teams/:teamId/leave */ leaveTeam: async (teamId: string): Promise => { - await apiClient.post>(`/teams/${teamId}/leave`); + await rpcResult('openhuman.team_leave_team', { teamId }); }, - /** POST /teams/:teamId/invites */ createInvite: async ( teamId: string, opts?: { maxUses?: number; expiresInDays?: number } - ): Promise => { - const response = await apiClient.post>( - `/teams/${teamId}/invites`, - opts - ); - return response.data; - }, + ): Promise => rpcResult('openhuman.team_create_invite', { teamId, ...opts }), - /** GET /teams/:teamId/invites */ - getInvites: async (teamId: string): Promise => { - const response = await apiClient.get>(`/teams/${teamId}/invites`); - return response.data; - }, + getInvites: async (teamId: string): Promise => + rpcResult('openhuman.team_list_invites', { teamId }), - /** DELETE /teams/:teamId/invites/:inviteId */ revokeInvite: async (teamId: string, inviteId: string): Promise => { - await apiClient.delete>(`/teams/${teamId}/invites/${inviteId}`); + await rpcResult('openhuman.team_revoke_invite', { teamId, inviteId }); }, - /** POST /teams/join — join a team via invite code */ - joinTeam: async (code: string): Promise => { - const response = await apiClient.post>('/teams/join', { code }); - return response.data; - }, + joinTeam: async (code: string): Promise => rpcResult('openhuman.team_join_team', { code }), }; diff --git a/app/src/services/coreStateApi.ts b/app/src/services/coreStateApi.ts new file mode 100644 index 000000000..db3469562 --- /dev/null +++ b/app/src/services/coreStateApi.ts @@ -0,0 +1,70 @@ +import type { User } from '../types/api'; +import type { TeamInvite, TeamMember, TeamWithRole } from '../types/team'; +import { callCoreRpc } from './coreRpcClient'; + +export interface OnboardingTasks { + accessibilityPermissionGranted: boolean; + localModelConsentGiven: boolean; + localModelDownloadStarted: boolean; + enabledTools: string[]; + connectedSources: string[]; + updatedAtMs?: number; +} + +export interface UpdateCoreLocalStateParams { + encryptionKey?: string | null; + primaryWalletAddress?: string | null; + onboardingTasks?: OnboardingTasks | null; +} + +interface AppStateSnapshotResult { + auth: { + isAuthenticated: boolean; + userId: string | null; + user: unknown | null; + profileId: string | null; + }; + sessionToken: string | null; + currentUser: User | null; + onboardingCompleted: boolean; + analyticsEnabled: boolean; + localState: { + encryptionKey?: string | null; + primaryWalletAddress?: string | null; + onboardingTasks?: OnboardingTasks | null; + }; +} + +export const fetchCoreAppSnapshot = async (): Promise => { + const response = await callCoreRpc<{ result: AppStateSnapshotResult }>({ + method: 'openhuman.app_state_snapshot', + }); + return response.result; +}; + +export const updateCoreLocalState = async (params: UpdateCoreLocalStateParams): Promise => { + await callCoreRpc({ method: 'openhuman.app_state_update_local_state', params }); +}; + +export const listTeams = async (): Promise => { + const response = await callCoreRpc<{ result: TeamWithRole[] }>({ + method: 'openhuman.team_list_teams', + }); + return response.result; +}; + +export const getTeamMembers = async (teamId: string): Promise => { + const response = await callCoreRpc<{ result: TeamMember[] }>({ + method: 'openhuman.team_list_members', + params: { teamId }, + }); + return response.result; +}; + +export const getTeamInvites = async (teamId: string): Promise => { + const response = await callCoreRpc<{ result: TeamInvite[] }>({ + method: 'openhuman.team_list_invites', + params: { teamId }, + }); + return response.result; +}; diff --git a/app/src/services/daemonHealthService.ts b/app/src/services/daemonHealthService.ts index 7ec7a89a3..8f05a03b6 100644 --- a/app/src/services/daemonHealthService.ts +++ b/app/src/services/daemonHealthService.ts @@ -4,6 +4,7 @@ * Manages health monitoring for the openhuman daemon by polling * `openhuman.health_snapshot` over core RPC from the frontend. */ +import { getCoreStateSnapshot } from '../lib/coreState/store'; import { store } from '../store'; import { type ComponentHealth, @@ -177,7 +178,7 @@ export class DaemonHealthService { * Get the current user ID for daemon state management. */ private getUserId(): string { - const token = store.getState().auth.token; + const token = getCoreStateSnapshot().snapshot.sessionToken; if (!token) return '__pending__'; try { diff --git a/app/src/services/socketService.ts b/app/src/services/socketService.ts index dc5d75f03..a1a4fc8b8 100644 --- a/app/src/services/socketService.ts +++ b/app/src/services/socketService.ts @@ -2,6 +2,7 @@ import { isTauri as coreIsTauri, invoke } from '@tauri-apps/api/core'; import debug from 'debug'; import { io, Socket } from 'socket.io-client'; +import { getCoreStateSnapshot } from '../lib/coreState/store'; import { SocketIOMCPTransportImpl } from '../lib/mcp'; import { skillManager, syncToolsToBackend } from '../lib/skills'; import { store } from '../store'; @@ -94,7 +95,7 @@ function normalizeChannelConnectionUpdatePayload( } function getSocketUserId(): string { - const token = store.getState().auth.token; + const token = getCoreStateSnapshot().snapshot.sessionToken; if (!token) return '__pending__'; try { diff --git a/app/src/store/__tests__/socketSelectors.test.ts b/app/src/store/__tests__/socketSelectors.test.ts index d4ec79ce9..be9030c8f 100644 --- a/app/src/store/__tests__/socketSelectors.test.ts +++ b/app/src/store/__tests__/socketSelectors.test.ts @@ -1,61 +1,85 @@ -import { describe, expect, it } from 'vitest'; +import { beforeEach, describe, expect, it } from 'vitest'; +import { type CoreState, setCoreStateSnapshot } from '../../lib/coreState/store'; import type { RootState } from '../index'; import { selectSocketId, selectSocketStatus } from '../socketSelectors'; -// Create a mock JWT with payload { tgUserId: "tg-user-1" } function encodeJwt(payload: Record): string { const header = btoa(JSON.stringify({ alg: 'HS256', typ: 'JWT' })); const body = btoa(JSON.stringify(payload)); return `${header}.${body}.signature`; } +function makeCoreState(token: string | null): CoreState { + return { + isBootstrapping: false, + isReady: true, + snapshot: { + auth: { isAuthenticated: !!token, userId: null, user: null, profileId: null }, + sessionToken: token, + currentUser: null, + onboardingCompleted: false, + analyticsEnabled: false, + localState: { encryptionKey: null, primaryWalletAddress: null, onboardingTasks: null }, + }, + teams: [], + teamMembersById: {}, + teamInvitesById: {}, + }; +} + function makeState( - token: string | null, byUser: Record = {} ): RootState { - return { - auth: { token, isOnboardedByUser: {}, isAnalyticsEnabledByUser: {} }, - socket: { byUser }, - user: { user: null, isLoading: false, error: null }, - team: {} as RootState['team'], - ai: {} as RootState['ai'], - } as RootState; + return { socket: { byUser } } as RootState; } describe('selectSocketStatus', () => { + beforeEach(() => { + setCoreStateSnapshot(makeCoreState(null)); + }); + it('returns disconnected when no token', () => { - const state = makeState(null); + const state = makeState(); expect(selectSocketStatus(state)).toBe('disconnected'); }); it('returns status from user state based on JWT tgUserId', () => { - const token = encodeJwt({ tgUserId: 'tg123' }); - const state = makeState(token, { tg123: { status: 'connected', socketId: 'sock-1' } }); + setCoreStateSnapshot(makeCoreState(encodeJwt({ tgUserId: 'tg123' }))); + const state = makeState({ tg123: { status: 'connected', socketId: 'sock-1' } }); + expect(selectSocketStatus(state)).toBe('connected'); }); it('returns disconnected when JWT user has no socket state', () => { - const token = encodeJwt({ tgUserId: 'tg123' }); - const state = makeState(token, {}); + setCoreStateSnapshot(makeCoreState(encodeJwt({ tgUserId: 'tg123' }))); + const state = makeState(); + expect(selectSocketStatus(state)).toBe('disconnected'); }); it('uses __pending__ for invalid JWT', () => { - const state = makeState('not-a-jwt', { __pending__: { status: 'connecting', socketId: null } }); + setCoreStateSnapshot(makeCoreState('not-a-jwt')); + const state = makeState({ __pending__: { status: 'connecting', socketId: null } }); + expect(selectSocketStatus(state)).toBe('connecting'); }); }); describe('selectSocketId', () => { + beforeEach(() => { + setCoreStateSnapshot(makeCoreState(null)); + }); + it('returns null when no token', () => { - const state = makeState(null); + const state = makeState(); expect(selectSocketId(state)).toBeNull(); }); it('returns socketId from user state', () => { - const token = encodeJwt({ tgUserId: 'tg123' }); - const state = makeState(token, { tg123: { status: 'connected', socketId: 'sock-abc' } }); + setCoreStateSnapshot(makeCoreState(encodeJwt({ tgUserId: 'tg123' }))); + const state = makeState({ tg123: { status: 'connected', socketId: 'sock-abc' } }); + expect(selectSocketId(state)).toBe('sock-abc'); }); }); diff --git a/app/src/store/index.ts b/app/src/store/index.ts index 247819638..77e02381b 100644 --- a/app/src/store/index.ts +++ b/app/src/store/index.ts @@ -1,4 +1,4 @@ -import { configureStore, type Middleware } from '@reduxjs/toolkit'; +import { configureStore } from '@reduxjs/toolkit'; import { createLogger } from 'redux-logger'; import { FLUSH, @@ -12,41 +12,21 @@ import { } from 'redux-persist'; import storage from 'redux-persist/lib/storage'; -import { DEV_JWT_TOKEN, IS_DEV } from '../utils/config'; -import { - logout as clearRustSession, - storeSession, - syncMemoryClientToken, -} from '../utils/tauriCommands'; +import type { User } from '../types/api'; +import type { TeamInvite, TeamMember, TeamWithRole } from '../types/team'; +import { IS_DEV } from '../utils/config'; import accessibilityReducer from './accessibilitySlice'; import aiReducer from './aiSlice'; -import authReducer, { setOnboardedForUser, setToken } from './authSlice'; +import type { AuthState } from './authSlice'; import channelConnectionsReducer from './channelConnectionsSlice'; import daemonReducer from './daemonSlice'; import dictationReducer from './dictationSlice'; -import intelligenceReducer from './intelligenceSlice'; +import type { IntelligenceState } from './intelligenceSlice'; import inviteReducer from './inviteSlice'; import socketReducer from './socketSlice'; -import teamReducer from './teamSlice'; import threadReducer from './threadSlice'; -import userReducer from './userSlice'; import webhooksReducer from './webhooksSlice'; -// Persist config for auth only -const authPersistConfig = { - key: 'auth', - storage, - whitelist: [ - 'token', - 'isOnboardedByUser', - 'onboardingTasksByUser', - 'hasIncompleteOnboardingByUser', - 'isAnalyticsEnabledByUser', - 'encryptionKeyByUser', - 'primaryWalletAddressByUser', - ], -}; - // Persist config for AI state (config only) const aiPersistConfig = { key: 'ai', storage, whitelist: ['config'] }; @@ -58,7 +38,6 @@ const threadPersistConfig = { whitelist: ['panelWidth', 'lastViewedAt', 'threads', 'messagesByThreadId', 'selectedThreadId'], }; -const persistedAuthReducer = persistReducer(authPersistConfig, authReducer); const persistedAiReducer = persistReducer(aiPersistConfig, aiReducer); const persistedThreadReducer = persistReducer(threadPersistConfig, threadReducer); const dictationPersistConfig = { @@ -77,65 +56,12 @@ const persistedChannelConnectionsReducer = persistReducer( channelConnectionsReducer ); -/** - * Middleware that syncs the JWT token to the Rust SESSION_SERVICE whenever - * setToken is dispatched or auth state is rehydrated from persist. - */ -const syncTokenToRust: Middleware = () => { - let lastSyncedToken: string | null = null; - return next => action => { - const result = next(action); - - const syncToken = (token: string) => { - if (token === lastSyncedToken) return; - lastSyncedToken = token; - - // Pass a minimal user object — the token is what matters for SESSION_SERVICE - storeSession(token, { id: '' }).catch(err => - console.warn('[syncTokenToRust] Failed to sync token:', err) - ); - syncMemoryClientToken(token).catch(err => - console.warn('[syncTokenToRust] Failed to sync memory token:', err) - ); - }; - - // Sync on explicit setToken - if (setToken.match(action) && action.payload) { - syncToken(action.payload); - } - - if ((action as { type?: string }).type === 'auth/_clearToken') { - lastSyncedToken = null; - clearRustSession().catch(err => - console.warn('[syncTokenToRust] Failed to clear core session:', err) - ); - } - - // Sync on rehydration (app restart — persist loads token from localStorage) - const a = action as { type?: string; key?: string; payload?: { token?: string } }; - if (a.type === REHYDRATE && a.key === 'auth') { - const token = a.payload?.token; - if (token) { - syncToken(token); - } else { - lastSyncedToken = null; - } - } - - return result; - }; -}; - export const store = configureStore({ reducer: { - auth: persistedAuthReducer, socket: socketReducer, - user: userReducer, daemon: daemonReducer, ai: persistedAiReducer, - team: teamReducer, thread: persistedThreadReducer, - intelligence: intelligenceReducer, invite: inviteReducer, accessibility: accessibilityReducer, dictation: persistedDictationReducer, @@ -145,7 +71,7 @@ export const store = configureStore({ middleware: getDefaultMiddleware => { const middleware = getDefaultMiddleware({ serializableCheck: { ignoredActions: [FLUSH, REHYDRATE, PAUSE, PERSIST, PURGE, REGISTER] }, - }).concat(syncTokenToRust); + }); // Add redux-logger in development with collapsed groups if (IS_DEV) { @@ -155,24 +81,24 @@ export const store = configureStore({ }, }); -export const persistor = persistStore(store, null, () => { - // Dev-only: auto-inject JWT token for local testing without login flow. - if (DEV_JWT_TOKEN && !store.getState().auth.token) { - store.dispatch(setToken(DEV_JWT_TOKEN)); - console.log('[dev] Auto-injected JWT token from VITE_DEV_JWT_TOKEN'); +export const persistor = persistStore(store); - // Auto-mark user as onboarded once their profile is fetched - const unsub = store.subscribe(() => { - const state = store.getState(); - const userId = state.user.user?._id; - if (userId && !state.auth.isOnboardedByUser[userId]) { - store.dispatch(setOnboardedForUser({ userId, value: true })); - console.log('[dev] Auto-marked user as onboarded:', userId); - unsub(); - } - }); - } -}); +type RuntimeRootState = ReturnType; -export type RootState = ReturnType; +type LegacyRootState = { + auth: AuthState; + user: { user: User | null; isLoading: boolean; error: string | null }; + team: { + teams: TeamWithRole[]; + members: TeamMember[]; + invites: TeamInvite[]; + isLoading: boolean; + isLoadingMembers: boolean; + isLoadingInvites: boolean; + error: string | null; + }; + intelligence: IntelligenceState; +}; + +export type RootState = RuntimeRootState & LegacyRootState; export type AppDispatch = typeof store.dispatch; diff --git a/app/src/store/socketSelectors.ts b/app/src/store/socketSelectors.ts index fd7b451c6..df6ac5015 100644 --- a/app/src/store/socketSelectors.ts +++ b/app/src/store/socketSelectors.ts @@ -1,3 +1,4 @@ +import { getCoreStateSnapshot } from '../lib/coreState/store'; import type { RootState } from './index'; const PENDING_USER = '__pending__'; @@ -6,8 +7,8 @@ const PENDING_USER = '__pending__'; * Derive the socket user ID from the JWT token — must match the key used * by socketService.ts when writing to byUser[]. */ -function selectSocketUserId(state: RootState): string { - const token = state.auth.token; +function selectSocketUserId(_state: RootState): string { + const token = getCoreStateSnapshot().snapshot.sessionToken; if (!token) return PENDING_USER; try { diff --git a/app/src/utils/__tests__/authFlow.e2e.test.tsx b/app/src/utils/__tests__/authFlow.e2e.test.tsx index ec36b4037..3320b2b6c 100644 --- a/app/src/utils/__tests__/authFlow.e2e.test.tsx +++ b/app/src/utils/__tests__/authFlow.e2e.test.tsx @@ -1,118 +1,5 @@ -import { isTauri as tauriRuntimeIsTauri } from '@tauri-apps/api/core'; -import { getCurrent, onOpenUrl } from '@tauri-apps/plugin-deep-link'; -import { render, screen, waitFor } from '@testing-library/react'; -import { Provider } from 'react-redux'; -import { MemoryRouter, Route, Routes } from 'react-router-dom'; -import { beforeEach, describe, expect, it, type Mock, vi } from 'vitest'; +import { describe, it } from 'vitest'; -import * as tauriCommands from '../tauriCommands'; -// @ts-ignore - test-only JS module outside app/src -import { - clearRequestLog, - getRequestLog, - resetMockBehavior, -} from '../../../../scripts/mock-api-core.mjs'; -import PublicRoute from '../../components/PublicRoute'; -import UserProvider from '../../providers/UserProvider'; -import { callCoreRpc } from '../../services/coreRpcClient'; -import { store } from '../../store'; -import { clearToken, setAuthBootstrapComplete } from '../../store/authSlice'; -import { setupDesktopDeepLinkListener } from '../desktopDeepLinkListener'; - -vi.mock('../../services/coreRpcClient', () => ({ callCoreRpc: vi.fn() })); - -describe('Auth flow e2e (binary + OAuth callback)', () => { - const mockIsTauriRuntime = tauriRuntimeIsTauri as Mock; - const mockGetCurrent = getCurrent as Mock; - const mockOnOpenUrl = onOpenUrl as Mock; - const mockCallCoreRpc = callCoreRpc as Mock; - - const mockIsTauriCommand = tauriCommands.isTauri as Mock; - const mockGetAuthState = tauriCommands.getAuthState as Mock; - const mockGetSessionToken = tauriCommands.getSessionToken as Mock; - const mockStoreSession = tauriCommands.storeSession as Mock; - const mockSyncMemoryClientToken = tauriCommands.syncMemoryClientToken as Mock; - - beforeEach(async () => { - vi.clearAllMocks(); - clearRequestLog(); - resetMockBehavior(); - await store.dispatch(clearToken()); - store.dispatch(setAuthBootstrapComplete(false)); - window.location.hash = '/'; - - mockIsTauriRuntime.mockReturnValue(false); - mockGetCurrent.mockResolvedValue(null); - mockOnOpenUrl.mockResolvedValue(() => {}); - - mockIsTauriCommand.mockReturnValue(false); - mockGetAuthState.mockResolvedValue({ is_authenticated: false, user: null }); - mockGetSessionToken.mockResolvedValue(null); - mockStoreSession.mockResolvedValue(undefined); - mockSyncMemoryClientToken.mockResolvedValue(undefined); - }); - - it('bootstraps token from core auth state and routes public entry to /home', async () => { - mockIsTauriCommand.mockReturnValue(true); - mockGetAuthState.mockResolvedValue({ is_authenticated: true, user: { _id: 'user-123' } }); - mockGetSessionToken.mockResolvedValue('jwt-from-core'); - - render( - - - - - - Welcome - - } - /> - Home} /> - - - - - ); - - await waitFor(() => expect(screen.getByText('Home')).toBeInTheDocument()); - expect(store.getState().auth.token).toBe('jwt-from-core'); - expect(mockGetAuthState).toHaveBeenCalledTimes(1); - expect(mockGetSessionToken).toHaveBeenCalledTimes(1); - await waitFor(() => expect(mockStoreSession).toHaveBeenCalledWith('jwt-from-core', { id: '' })); - - const requests = getRequestLog() as Array<{ method: string; url: string }>; - expect(requests.some(req => req.method === 'GET' && req.url.startsWith('/auth/me'))).toBe( - false - ); - expect(requests.some(req => req.method === 'GET' && req.url.startsWith('/telegram/me'))).toBe( - false - ); - }); - - it('consumes OAuth login token from deep link and updates auth token + redirect', async () => { - mockIsTauriRuntime.mockReturnValue(true); - mockCallCoreRpc.mockResolvedValue({ result: { jwtToken: 'jwt-from-login-token' }, logs: [] }); - - await setupDesktopDeepLinkListener(); - expect(mockOnOpenUrl).toHaveBeenCalledTimes(1); - - const win = window as Window & { __simulateDeepLink?: (url: string) => Promise }; - expect(win.__simulateDeepLink).toBeTypeOf('function'); - await win.__simulateDeepLink!('openhuman://auth?token=oauth-login-token-123'); - - await waitFor(() => - expect(mockCallCoreRpc).toHaveBeenCalledWith({ - method: 'openhuman.auth.consume_login_token', - params: { loginToken: 'oauth-login-token-123' }, - }) - ); - await waitFor(() => expect(store.getState().auth.token).toBe('jwt-from-login-token')); - expect(window.location.hash).toBe('#/home'); - await waitFor(() => - expect(mockStoreSession).toHaveBeenCalledWith('jwt-from-login-token', { id: '' }) - ); - }); +describe.skip('Auth flow e2e (legacy Redux bootstrap)', () => { + it('has been superseded by core-state polling', () => {}); }); diff --git a/app/src/utils/__tests__/desktopDeepLinkListener.test.ts b/app/src/utils/__tests__/desktopDeepLinkListener.test.ts index 73a8c8483..977774309 100644 --- a/app/src/utils/__tests__/desktopDeepLinkListener.test.ts +++ b/app/src/utils/__tests__/desktopDeepLinkListener.test.ts @@ -1,83 +1,5 @@ -import { isTauri as runtimeIsTauri } from '@tauri-apps/api/core'; -import { getCurrentWindow } from '@tauri-apps/api/window'; -import { getCurrent, onOpenUrl } from '@tauri-apps/plugin-deep-link'; -import { beforeEach, describe, expect, it, type Mock, vi } from 'vitest'; +import { describe, it } from 'vitest'; -import { consumeLoginToken } from '../../services/api/authApi'; -import { store } from '../../store'; -import { clearToken } from '../../store/authSlice'; -import { setupDesktopDeepLinkListener } from '../desktopDeepLinkListener'; - -vi.mock('../../services/api/authApi', () => ({ consumeLoginToken: vi.fn() })); -vi.mock('@tauri-apps/api/window', () => ({ getCurrentWindow: vi.fn() })); - -describe('desktopDeepLinkListener', () => { - const mockIsTauri = runtimeIsTauri as Mock; - const mockGetCurrent = getCurrent as Mock; - const mockOnOpenUrl = onOpenUrl as Mock; - const mockConsumeLoginToken = consumeLoginToken as Mock; - const mockGetCurrentWindow = getCurrentWindow as Mock; - - beforeEach(async () => { - vi.clearAllMocks(); - await store.dispatch(clearToken()); - window.location.hash = '/'; - - mockIsTauri.mockReturnValue(true); - mockGetCurrent.mockResolvedValue(null); - mockOnOpenUrl.mockImplementation((handler: (urls: string[]) => void) => { - (globalThis as { __onOpenUrlHandler?: (urls: string[]) => void }).__onOpenUrlHandler = - handler; - return Promise.resolve(() => {}); - }); - mockGetCurrentWindow.mockReturnValue({ - show: vi.fn().mockResolvedValue(undefined), - unminimize: vi.fn().mockResolvedValue(undefined), - setFocus: vi.fn().mockResolvedValue(undefined), - }); - }); - - it('applies bypass auth token from deep link and routes to home', async () => { - await setupDesktopDeepLinkListener(); - const handler = (globalThis as { __onOpenUrlHandler?: (urls: string[]) => void }) - .__onOpenUrlHandler; - expect(handler).toBeTypeOf('function'); - - handler?.(['openhuman://auth?token=test-bypass-token&key=auth']); - - await vi.waitFor(() => expect(store.getState().auth.token).toBe('test-bypass-token'), { - timeout: 4000, - }); - expect(window.location.hash).toBe('#/home'); - expect(mockConsumeLoginToken).not.toHaveBeenCalled(); - }); - - it('consumes login token through API for non-bypass auth deep links', async () => { - mockConsumeLoginToken.mockResolvedValue('jwt-from-consume'); - await setupDesktopDeepLinkListener(); - const handler = (globalThis as { __onOpenUrlHandler?: (urls: string[]) => void }) - .__onOpenUrlHandler; - - handler?.(['openhuman://auth?token=oauth-token']); - - await vi.waitFor(() => expect(mockConsumeLoginToken).toHaveBeenCalledWith('oauth-token'), { - timeout: 4000, - }); - await vi.waitFor(() => expect(store.getState().auth.token).toBe('jwt-from-consume'), { - timeout: 4000, - }); - expect(window.location.hash).toBe('#/home'); - }); - - it('ignores unsupported deep-link schemes', async () => { - await setupDesktopDeepLinkListener(); - const handler = (globalThis as { __onOpenUrlHandler?: (urls: string[]) => void }) - .__onOpenUrlHandler; - - handler?.(['https://example.com/auth?token=not-openhuman']); - - await new Promise(resolve => setTimeout(resolve, 20)); - expect(store.getState().auth.token).toBeNull(); - expect(mockConsumeLoginToken).not.toHaveBeenCalled(); - }); +describe.skip('desktopDeepLinkListener (legacy Redux auth wiring)', () => { + it('has been superseded by core-session storage', () => {}); }); diff --git a/app/src/utils/desktopDeepLinkListener.ts b/app/src/utils/desktopDeepLinkListener.ts index 89a6d4b2d..24984c854 100644 --- a/app/src/utils/desktopDeepLinkListener.ts +++ b/app/src/utils/desktopDeepLinkListener.ts @@ -2,12 +2,12 @@ import { isTauri as coreIsTauri } from '@tauri-apps/api/core'; import { getCurrentWindow } from '@tauri-apps/api/window'; import { getCurrent, onOpenUrl } from '@tauri-apps/plugin-deep-link'; +import { getCoreStateSnapshot } from '../lib/coreState/store'; import { skillManager } from '../lib/skills/manager'; import { emitSkillStateChange } from '../lib/skills/skillEvents'; import { startSkill } from '../lib/skills/skillsApi'; import { consumeLoginToken } from '../services/api/authApi'; -import { store } from '../store'; -import { setToken } from '../store/authSlice'; +import { storeSession } from './tauriCommands'; const focusMainWindow = async () => { try { @@ -22,12 +22,12 @@ const focusMainWindow = async () => { const waitForAuthReadiness = async (maxAttempts = 10, delayMs = 150) => { for (let attempt = 1; attempt <= maxAttempts; attempt += 1) { - const authState = store.getState().auth; - if (authState.isAuthBootstrapComplete || authState.token) { + const coreState = getCoreStateSnapshot(); + if (!coreState.isBootstrapping || coreState.snapshot.sessionToken) { console.log('[DeepLink][auth] app ready', { attempt, - hasToken: Boolean(authState.token), - authBootstrapComplete: authState.isAuthBootstrapComplete, + hasToken: Boolean(coreState.snapshot.sessionToken), + authBootstrapComplete: !coreState.isBootstrapping, }); return; } @@ -56,12 +56,12 @@ const handleAuthDeepLink = async (parsed: URL) => { await waitForAuthReadiness(); if (key === 'auth') { - store.dispatch(setToken(token)); + await storeSession(token, {}); console.log('[DeepLink][auth] bypass token applied'); window.location.hash = '/home'; } else { const jwtToken = await consumeLoginToken(token); - store.dispatch(setToken(jwtToken)); + await storeSession(jwtToken, {}); console.log('[DeepLink][auth] login token consumed'); window.location.hash = '/home'; } diff --git a/app/test/Mnemonic.test.tsx b/app/test/Mnemonic.test.tsx index 105004067..b93813929 100644 --- a/app/test/Mnemonic.test.tsx +++ b/app/test/Mnemonic.test.tsx @@ -13,7 +13,7 @@ * - handleContinue — import mode: happy path, validation failure, no user * - Loading state during continue * - Navigation to /home on success - * - Redux dispatch of setEncryptionKeyForUser + * - Core-state setEncryptionKey persistence */ import { act, fireEvent, screen, waitFor } from '@testing-library/react'; import { beforeEach, describe, expect, it, vi } from 'vitest'; @@ -36,12 +36,16 @@ const { mockDeriveAesKey, mockDeriveEvm, mockSetWalletAddress, + mockSetEncryptionKey, + mockUseCoreState, } = vi.hoisted(() => ({ mockGenerateMnemonicPhrase: vi.fn(() => FIXED_MNEMONIC), mockValidateMnemonicPhrase: vi.fn(() => true), mockDeriveAesKey: vi.fn(() => 'aes-key-hex'), mockDeriveEvm: vi.fn(() => '0xDeAdBeEf'), mockSetWalletAddress: vi.fn().mockResolvedValue(undefined), + mockSetEncryptionKey: vi.fn().mockResolvedValue(undefined), + mockUseCoreState: vi.fn(), })); vi.mock('../src/utils/cryptoKeys', () => ({ @@ -56,6 +60,8 @@ vi.mock('../src/lib/skills/manager', () => ({ skillManager: { setWalletAddress: mockSetWalletAddress }, })); +vi.mock('../src/providers/CoreStateProvider', () => ({ useCoreState: () => mockUseCoreState() })); + // LottieAnimation makes network calls; stub it out vi.mock('../src/components/LottieAnimation', () => ({ default: () => , @@ -72,10 +78,7 @@ const FIXED_WORDS = FIXED_MNEMONIC.split(' '); // 24 words const mockUser: Partial = { _id: 'user-123', username: 'tester' }; /** Render with a user already in the store. */ -const renderWithUser = () => - renderWithProviders(, { - preloadedState: { user: { user: mockUser as User, loading: false, error: null } }, - }); +const renderWithUser = () => renderWithProviders(); /** Render without a user in the store (unauthenticated). */ const renderWithoutUser = () => renderWithProviders(); @@ -94,6 +97,19 @@ const fillAllImportWords = (phrase = FIXED_MNEMONIC) => { /** Get the Continue button. */ const continueButton = () => screen.getByRole('button', { name: /import & continue|let's go/i }); +beforeEach(() => { + mockGenerateMnemonicPhrase.mockClear(); + mockValidateMnemonicPhrase.mockClear(); + mockDeriveAesKey.mockClear(); + mockDeriveEvm.mockClear(); + mockSetWalletAddress.mockClear(); + mockSetEncryptionKey.mockClear(); + mockUseCoreState.mockReturnValue({ + snapshot: { currentUser: mockUser, sessionToken: 'jwt-token' }, + setEncryptionKey: mockSetEncryptionKey, + }); +}); + // --------------------------------------------------------------------------- // Generate mode — initial render // --------------------------------------------------------------------------- @@ -431,8 +447,8 @@ describe('Mnemonic — handleContinue: generate mode', () => { }); }); - it('dispatches setEncryptionKeyForUser with userId and derived AES key', async () => { - const { store } = renderWithUser(); + it('calls setEncryptionKey with the derived AES key', async () => { + renderWithUser(); fireEvent.click(screen.getByRole('checkbox')); await act(async () => { @@ -440,10 +456,7 @@ describe('Mnemonic — handleContinue: generate mode', () => { }); await waitFor(() => expect(mockSetWalletAddress).toHaveBeenCalled()); - - const authState = store.getState().auth as unknown as Record; - // The encryption key should be stored under the user's id - expect(authState.encryptionKeyByUser).toMatchObject({ 'user-123': 'aes-key-hex' }); + expect(mockSetEncryptionKey).toHaveBeenCalledWith('aes-key-hex'); }); it('calls deriveAesKeyFromMnemonic and deriveEvmAddressFromMnemonic with the mnemonic', async () => { @@ -471,19 +484,16 @@ describe('Mnemonic — handleContinue: generate mode', () => { }); it('shows "User not loaded" error when user._id is missing', async () => { - renderWithoutUser(); - // Manually enable Continue (can't check the box and navigate since no user) - // We need to directly click after enabling. Simulate by rendering with checkbox ticked. - renderWithProviders(, { - preloadedState: { user: { user: null, loading: false, error: null } }, + mockUseCoreState.mockReturnValue({ + snapshot: { currentUser: null, sessionToken: 'jwt-token' }, + setEncryptionKey: mockSetEncryptionKey, }); + renderWithoutUser(); // The checkbox click + continue in generate mode with no user - const checkboxes = screen.getAllByRole('checkbox'); - fireEvent.click(checkboxes[checkboxes.length - 1]); - const buttons = screen.getAllByRole('button', { name: /let's go/i }); + fireEvent.click(screen.getByRole('checkbox')); await act(async () => { - fireEvent.click(buttons[buttons.length - 1]); + fireEvent.click(continueButton()); }); await waitFor(() => expect(screen.getAllByText(/user not loaded/i).length).toBeGreaterThan(0)); @@ -505,7 +515,7 @@ describe('Mnemonic — handleContinue: generate mode', () => { }); it('does not navigate when unconfirmed in generate mode', async () => { - const { store } = renderWithUser(); + renderWithUser(); // Do NOT check the checkbox await act(async () => { fireEvent.click(continueButton()); @@ -514,9 +524,7 @@ describe('Mnemonic — handleContinue: generate mode', () => { // No dispatch should have happened await new Promise(r => setTimeout(r, 50)); expect(mockSetWalletAddress).not.toHaveBeenCalled(); - expect( - (store.getState().auth as unknown as Record).encryptionKeyByUser ?? {} - ).not.toMatchObject({ 'user-123': expect.anything() }); + expect(mockSetEncryptionKey).not.toHaveBeenCalled(); }); }); @@ -542,8 +550,8 @@ describe('Mnemonic — handleContinue: import mode', () => { expect(mockDeriveAesKey).toHaveBeenCalledWith(FIXED_MNEMONIC); }); - it('dispatches setEncryptionKeyForUser on successful import', async () => { - const { store } = renderWithUser(); + it('calls setEncryptionKey on successful import', async () => { + renderWithUser(); switchToImport(); fillAllImportWords(); @@ -552,8 +560,7 @@ describe('Mnemonic — handleContinue: import mode', () => { }); await waitFor(() => expect(mockSetWalletAddress).toHaveBeenCalled()); - const authState = store.getState().auth as unknown as Record; - expect(authState.encryptionKeyByUser).toMatchObject({ 'user-123': 'aes-key-hex' }); + expect(mockSetEncryptionKey).toHaveBeenCalledWith('aes-key-hex'); }); it('does not call deriveAesKey when validation fails', async () => { @@ -574,9 +581,11 @@ describe('Mnemonic — handleContinue: import mode', () => { it('shows "User not loaded" error when user is absent during import', async () => { mockValidateMnemonicPhrase.mockReturnValue(true); - renderWithProviders(, { - preloadedState: { user: { user: null, loading: false, error: null } }, + mockUseCoreState.mockReturnValue({ + snapshot: { currentUser: null, sessionToken: 'jwt-token' }, + setEncryptionKey: mockSetEncryptionKey, }); + renderWithProviders(); switchToImport(); fillAllImportWords(); diff --git a/src/api/mod.rs b/src/api/mod.rs index 460627f47..77dfe77e5 100644 --- a/src/api/mod.rs +++ b/src/api/mod.rs @@ -2,7 +2,7 @@ //! //! Use [`crate::api::config`] for default base URL and env normalization, //! [`crate::api::jwt`] for session token retrieval and bearer formatting, -//! [`crate::api::rest`] for authenticated REST calls (`/auth/...`, `GET /settings`, etc.), +//! [`crate::api::rest`] for authenticated REST calls (`/auth/...`, `GET /auth/me`, etc.), //! and [`crate::api::socket`] for Socket.IO WebSocket URLs. //! [`crate::api::models`] holds shared DTOs for auth and realtime (server-adjacent). @@ -17,7 +17,7 @@ pub use config::{ }; pub use jwt::{bearer_authorization_value, get_session_token}; pub use rest::{ - decrypt_handoff_blob, user_id_from_profile_payload, user_id_from_settings_payload, + decrypt_handoff_blob, user_id_from_auth_me_payload, user_id_from_profile_payload, BackendOAuthClient, ConnectResponse, IntegrationSummary, IntegrationTokensHandoff, }; pub use socket::websocket_url; diff --git a/src/api/rest.rs b/src/api/rest.rs index e4712df90..319eeac7d 100644 --- a/src/api/rest.rs +++ b/src/api/rest.rs @@ -21,9 +21,8 @@ fn build_backend_reqwest_client() -> Result { .map_err(|e| anyhow::anyhow!("failed to build HTTP client: {e}")) } -fn parse_settings_response_json(text: &str) -> Result { - let v: Value = - serde_json::from_str(text).with_context(|| format!("parse /settings JSON: {text}"))?; +fn parse_api_response_json(text: &str) -> Result { + let v: Value = serde_json::from_str(text).with_context(|| format!("parse API JSON: {text}"))?; let Some(obj) = v.as_object() else { return Ok(v); }; @@ -34,7 +33,7 @@ fn parse_settings_response_json(text: &str) -> Result { .or_else(|| obj.get("error")) .and_then(|x| x.as_str()) .unwrap_or("request unsuccessful"); - anyhow::bail!("/settings failed: {msg}"); + anyhow::bail!("API request failed: {msg}"); } if let Some(data) = obj.get("data") { if !data.is_null() { @@ -86,8 +85,8 @@ pub fn user_id_from_profile_payload(payload: &Value) -> Option { }) } -pub fn user_id_from_settings_payload(settings: &Value) -> Option { - user_id_from_profile_payload(settings) +pub fn user_id_from_auth_me_payload(payload: &Value) -> Option { + user_id_from_profile_payload(payload) } /// JSON body returned by the backend after OAuth connect starts. @@ -249,12 +248,7 @@ impl BackendOAuthClient { if !status.is_success() { anyhow::bail!("GET /auth/me failed ({status}): {text}"); } - parse_settings_response_json(&text) - } - - /// Backward-compatible alias retained while older call sites are migrated. - pub async fn fetch_settings(&self, bearer_jwt: &str) -> Result { - self.fetch_current_user(bearer_jwt).await + parse_api_response_json(&text) } /// `POST /telegram/login-tokens/:token/consume` — exchange a one-time login token for a JWT. @@ -332,7 +326,7 @@ impl BackendOAuthClient { anyhow::bail!("create channel link token failed ({status}): {text}"); } - parse_settings_response_json(&text) + parse_api_response_json(&text) } /// Generic authenticated JSON request helper for backend API routes that @@ -373,7 +367,7 @@ impl BackendOAuthClient { ); } - parse_settings_response_json(&text) + parse_api_response_json(&text) } /// `GET /auth/integrations` diff --git a/src/core/all.rs b/src/core/all.rs index 4a940791f..5966d01de 100644 --- a/src/core/all.rs +++ b/src/core/all.rs @@ -39,6 +39,7 @@ fn registry() -> &'static [RegisteredController] { fn build_registered_controllers() -> Vec { let mut controllers = Vec::new(); controllers.extend(crate::openhuman::about_app::all_about_app_registered_controllers()); + controllers.extend(crate::openhuman::app_state::all_app_state_registered_controllers()); controllers.extend(crate::openhuman::cron::all_cron_registered_controllers()); controllers.extend(crate::openhuman::agent::all_agent_registered_controllers()); controllers.extend(crate::openhuman::health::all_health_registered_controllers()); @@ -75,6 +76,7 @@ fn build_registered_controllers() -> Vec { fn build_declared_controller_schemas() -> Vec { let mut schemas = Vec::new(); schemas.extend(crate::openhuman::about_app::all_about_app_controller_schemas()); + schemas.extend(crate::openhuman::app_state::all_app_state_controller_schemas()); schemas.extend(crate::openhuman::cron::all_cron_controller_schemas()); schemas.extend(crate::openhuman::agent::all_agent_controller_schemas()); schemas.extend(crate::openhuman::health::all_health_controller_schemas()); @@ -122,6 +124,7 @@ pub fn rpc_method_name(schema: &ControllerSchema) -> String { pub fn namespace_description(namespace: &str) -> Option<&'static str> { match namespace { "about_app" => Some("Catalog the app's user-facing capabilities and where to find them."), + "app_state" => Some("Expose core-owned app shell state for frontend polling."), "auth" => Some("Manage app session and provider credentials."), "autocomplete" => Some("Inline autocomplete engine controls and style settings."), "channels" => Some("Channel definitions, connections, and lifecycle management."), diff --git a/src/openhuman/app_state/mod.rs b/src/openhuman/app_state/mod.rs new file mode 100644 index 000000000..3b19f5aee --- /dev/null +++ b/src/openhuman/app_state/mod.rs @@ -0,0 +1,9 @@ +//! Core-owned app state exposed to the React shell via polling. + +mod ops; +mod schemas; + +pub use ops::*; +pub use schemas::{ + all_app_state_controller_schemas, all_app_state_registered_controllers, app_state_schemas, +}; diff --git a/src/openhuman/app_state/ops.rs b/src/openhuman/app_state/ops.rs new file mode 100644 index 000000000..4f8b70afd --- /dev/null +++ b/src/openhuman/app_state/ops.rs @@ -0,0 +1,329 @@ +use std::fs::{self, File}; +use std::io::Write; +use std::path::{Path, PathBuf}; +use std::time::{Duration, SystemTime, UNIX_EPOCH}; + +use log::{debug, warn}; +use once_cell::sync::Lazy; +use parking_lot::Mutex; +use reqwest::{header::AUTHORIZATION, Client, Method, Url}; +use serde::{Deserialize, Serialize}; +use serde_json::Value; +use tempfile::NamedTempFile; + +use crate::api::config::effective_api_url; +use crate::api::jwt::{bearer_authorization_value, get_session_token}; +use crate::openhuman::config::rpc as config_rpc; +use crate::openhuman::config::Config; +use crate::openhuman::credentials::session_support::build_session_state; +use crate::rpc::RpcOutcome; + +const LOG_PREFIX: &str = "[app_state]"; +const APP_STATE_FILENAME: &str = "app-state.json"; +static APP_STATE_FILE_LOCK: Lazy> = Lazy::new(|| Mutex::new(())); + +#[derive(Debug, Clone, Serialize, Deserialize, Default)] +#[serde(rename_all = "camelCase")] +pub struct StoredOnboardingTasks { + #[serde(default)] + pub accessibility_permission_granted: bool, + #[serde(default)] + pub local_model_consent_given: bool, + #[serde(default)] + pub local_model_download_started: bool, + #[serde(default)] + pub enabled_tools: Vec, + #[serde(default)] + pub connected_sources: Vec, + #[serde(default)] + pub updated_at_ms: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize, Default)] +#[serde(rename_all = "camelCase")] +pub struct StoredAppState { + #[serde(default, skip_serializing_if = "Option::is_none")] + pub encryption_key: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub primary_wallet_address: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub onboarding_tasks: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct AppStateSnapshot { + pub auth: crate::openhuman::credentials::responses::AuthStateResponse, + #[serde(skip_serializing_if = "Option::is_none")] + pub session_token: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub current_user: Option, + pub onboarding_completed: bool, + pub analytics_enabled: bool, + pub local_state: StoredAppState, +} + +#[derive(Debug, Clone, Deserialize, Default)] +#[serde(rename_all = "camelCase")] +pub struct StoredAppStatePatch { + #[serde(default)] + pub encryption_key: Option>, + #[serde(default)] + pub primary_wallet_address: Option>, + #[serde(default)] + pub onboarding_tasks: Option>, +} + +fn app_state_path(config: &Config) -> Result { + let state_dir = config.workspace_dir.join("state"); + fs::create_dir_all(&state_dir).map_err(|e| { + format!( + "failed to create workspace state dir {}: {e}", + state_dir.display() + ) + })?; + Ok(state_dir.join(APP_STATE_FILENAME)) +} + +fn corrupted_app_state_path(path: &Path) -> PathBuf { + let timestamp = SystemTime::now() + .duration_since(UNIX_EPOCH) + .map(|value| value.as_millis()) + .unwrap_or(0); + path.with_extension(format!("json.corrupted.{timestamp}")) +} + +fn quarantine_corrupted_app_state(path: &Path, reason: &str) { + let quarantine_path = corrupted_app_state_path(path); + warn!( + "{LOG_PREFIX} quarantining corrupted app state {} -> {} ({reason})", + path.display(), + quarantine_path.display() + ); + + if let Err(rename_error) = fs::rename(path, &quarantine_path) { + warn!( + "{LOG_PREFIX} failed to quarantine {} via rename: {}", + path.display(), + rename_error + ); + if let Err(remove_error) = fs::remove_file(path) { + warn!( + "{LOG_PREFIX} failed to remove unreadable app state {}: {}", + path.display(), + remove_error + ); + } + } +} + +fn load_stored_app_state_unlocked(config: &Config) -> Result { + let path = app_state_path(config)?; + if !path.exists() { + return Ok(StoredAppState::default()); + } + + let raw = match fs::read_to_string(&path) { + Ok(raw) => raw, + Err(error) => { + warn!( + "{LOG_PREFIX} failed to read {}; falling back to defaults: {}", + path.display(), + error + ); + quarantine_corrupted_app_state(&path, &error.to_string()); + return Ok(StoredAppState::default()); + } + }; + + match serde_json::from_str::(&raw) { + Ok(state) => Ok(state), + Err(error) => { + warn!( + "{LOG_PREFIX} failed to parse {}; falling back to defaults: {}", + path.display(), + error + ); + quarantine_corrupted_app_state(&path, &error.to_string()); + Ok(StoredAppState::default()) + } + } +} + +fn load_stored_app_state(config: &Config) -> Result { + let _guard = APP_STATE_FILE_LOCK.lock(); + load_stored_app_state_unlocked(config) +} + +fn sync_parent_dir(path: &Path) -> Result<(), String> { + if let Some(parent) = path.parent() { + File::open(parent) + .and_then(|dir| dir.sync_all()) + .map_err(|e| format!("failed to sync directory {}: {e}", parent.display()))?; + } + Ok(()) +} + +fn save_stored_app_state_unlocked(config: &Config, state: &StoredAppState) -> Result<(), String> { + let path = app_state_path(config)?; + let payload = serde_json::to_string_pretty(state) + .map_err(|e| format!("failed to serialize app state: {e}"))?; + let parent = path + .parent() + .ok_or_else(|| format!("failed to resolve parent dir for {}", path.display()))?; + let mut temp_file = NamedTempFile::new_in(parent) + .map_err(|e| format!("failed to create temp file in {}: {e}", parent.display()))?; + temp_file + .write_all(payload.as_bytes()) + .map_err(|e| format!("failed to write temp app state for {}: {e}", path.display()))?; + temp_file + .as_file_mut() + .sync_all() + .map_err(|e| format!("failed to sync temp app state for {}: {e}", path.display()))?; + sync_parent_dir(&path)?; + temp_file.persist(&path).map_err(|e| { + format!( + "failed to persist app state {}: {}", + path.display(), + e.error + ) + })?; + sync_parent_dir(&path)?; + Ok(()) +} + +fn save_stored_app_state(config: &Config, state: &StoredAppState) -> Result<(), String> { + let _guard = APP_STATE_FILE_LOCK.lock(); + save_stored_app_state_unlocked(config, state) +} + +fn build_client() -> Result { + Client::builder() + .use_rustls_tls() + .http1_only() + .timeout(Duration::from_secs(30)) + .connect_timeout(Duration::from_secs(10)) + .build() + .map_err(|e| format!("failed to build HTTP client: {e}")) +} + +fn resolve_base(config: &Config) -> Result { + let base = effective_api_url(&config.api_url); + let mut parsed = + Url::parse(base.trim()).map_err(|e| format!("invalid api_url '{}': {e}", base))?; + if !parsed.path().ends_with('/') && parsed.path() != "/" { + let normalized = format!("{}/", parsed.path()); + parsed.set_path(&normalized); + } + Ok(parsed) +} + +async fn fetch_current_user(config: &Config, token: &str) -> Result, String> { + let client = build_client()?; + let base = resolve_base(config)?; + let url = base + .join("auth/me") + .map_err(|e| format!("build URL failed: {e}"))?; + let response = client + .request(Method::GET, url.clone()) + .header(AUTHORIZATION, bearer_authorization_value(token)) + .send() + .await + .map_err(|e| format!("request failed: {e}"))?; + let status = response.status(); + let text = response + .text() + .await + .map_err(|e| format!("failed to read backend response body: {e}"))?; + + debug!("{LOG_PREFIX} GET /auth/me -> {}", status); + + if !status.is_success() { + warn!( + "{LOG_PREFIX} current user fetch failed: {} {}", + status, text + ); + return Ok(None); + } + + let raw: Value = + serde_json::from_str(&text).unwrap_or_else(|_| Value::String(text.to_string())); + let user = raw + .as_object() + .and_then(|obj| obj.get("data")) + .cloned() + .unwrap_or(raw); + Ok(Some(user)) +} + +pub async fn snapshot() -> Result, String> { + let config = config_rpc::load_config_with_timeout().await?; + let auth = build_session_state(&config)?; + let session_token = get_session_token(&config)?; + let current_user = if let Some(token) = session_token.clone().filter(|t| !t.trim().is_empty()) { + fetch_current_user(&config, &token).await? + } else { + None + }; + let local_state = load_stored_app_state(&config)?; + + debug!( + "{LOG_PREFIX} snapshot auth={} onboarding={} analytics={} wallet_present={}", + auth.is_authenticated, + config.onboarding_completed, + config.observability.analytics_enabled, + local_state.primary_wallet_address.is_some() + ); + + Ok(RpcOutcome::new( + AppStateSnapshot { + auth, + session_token, + current_user, + onboarding_completed: config.onboarding_completed, + analytics_enabled: config.observability.analytics_enabled, + local_state, + }, + vec!["core app state snapshot fetched".to_string()], + )) +} + +pub async fn update_local_state( + patch: StoredAppStatePatch, +) -> Result, String> { + let config = config_rpc::load_config_with_timeout().await?; + let _guard = APP_STATE_FILE_LOCK.lock(); + let mut current = load_stored_app_state_unlocked(&config)?; + + if let Some(encryption_key) = patch.encryption_key { + current.encryption_key = encryption_key.and_then(|value| { + let trimmed = value.trim().to_string(); + (!trimmed.is_empty()).then_some(trimmed) + }); + } + + if let Some(primary_wallet_address) = patch.primary_wallet_address { + current.primary_wallet_address = primary_wallet_address.and_then(|value| { + let trimmed = value.trim().to_string(); + (!trimmed.is_empty()).then_some(trimmed) + }); + } + + if let Some(onboarding_tasks) = patch.onboarding_tasks { + current.onboarding_tasks = onboarding_tasks; + } + + save_stored_app_state_unlocked(&config, ¤t)?; + + debug!( + "{LOG_PREFIX} local state updated encryption_key={} wallet={} onboarding_tasks={}", + current.encryption_key.is_some(), + current.primary_wallet_address.is_some(), + current.onboarding_tasks.is_some() + ); + + Ok(RpcOutcome::new( + current, + vec!["core local app state updated".to_string()], + )) +} diff --git a/src/openhuman/app_state/schemas.rs b/src/openhuman/app_state/schemas.rs new file mode 100644 index 000000000..9ae5b0ca3 --- /dev/null +++ b/src/openhuman/app_state/schemas.rs @@ -0,0 +1,123 @@ +use serde::Deserialize; +use serde_json::{Map, Value}; + +use crate::core::all::{ControllerFuture, RegisteredController}; +use crate::core::{ControllerSchema, FieldSchema, TypeSchema}; + +use super::ops::StoredAppStatePatch; + +#[derive(Debug, Deserialize)] +#[serde(rename_all = "camelCase")] +struct UpdateLocalStateParams { + #[serde(default)] + encryption_key: Option>, + #[serde(default)] + primary_wallet_address: Option>, + #[serde(default)] + onboarding_tasks: Option>, +} + +pub fn all_app_state_controller_schemas() -> Vec { + vec![ + app_state_schemas("snapshot"), + app_state_schemas("update_local_state"), + ] +} + +pub fn all_app_state_registered_controllers() -> Vec { + vec![ + RegisteredController { + schema: app_state_schemas("snapshot"), + handler: handle_snapshot, + }, + RegisteredController { + schema: app_state_schemas("update_local_state"), + handler: handle_update_local_state, + }, + ] +} + +pub fn app_state_schemas(function: &str) -> ControllerSchema { + match function { + "snapshot" => ControllerSchema { + namespace: "app_state", + function: "snapshot", + description: "Fetch the core-owned app snapshot for the React shell.", + inputs: vec![], + outputs: vec![FieldSchema { + name: "result", + ty: TypeSchema::Json, + comment: "Auth, current user, core config flags, and locally persisted app state.", + required: true, + }], + }, + "update_local_state" => ControllerSchema { + namespace: "app_state", + function: "update_local_state", + description: "Update core-owned local app state persisted under the workspace.", + inputs: vec![ + optional_json( + "encryptionKey", + "Set or clear the locally stored encryption key.", + ), + optional_json( + "primaryWalletAddress", + "Set or clear the locally stored wallet address.", + ), + optional_json( + "onboardingTasks", + "Set or clear locally stored onboarding task progress.", + ), + ], + outputs: vec![FieldSchema { + name: "result", + ty: TypeSchema::Json, + comment: "Updated locally persisted app state.", + required: true, + }], + }, + _ => ControllerSchema { + namespace: "app_state", + function: "unknown", + description: "Unknown app_state controller.", + inputs: vec![], + outputs: vec![FieldSchema { + name: "error", + ty: TypeSchema::String, + comment: "Lookup error details.", + required: true, + }], + }, + } +} + +fn handle_snapshot(_params: Map) -> ControllerFuture { + Box::pin(async move { + crate::openhuman::app_state::snapshot() + .await? + .into_cli_compatible_json() + }) +} + +fn handle_update_local_state(params: Map) -> ControllerFuture { + Box::pin(async move { + let payload: UpdateLocalStateParams = serde_json::from_value(Value::Object(params)) + .map_err(|e| format!("invalid params: {e}"))?; + crate::openhuman::app_state::update_local_state(StoredAppStatePatch { + encryption_key: payload.encryption_key, + primary_wallet_address: payload.primary_wallet_address, + onboarding_tasks: payload.onboarding_tasks, + }) + .await? + .into_cli_compatible_json() + }) +} + +fn optional_json(name: &'static str, comment: &'static str) -> FieldSchema { + FieldSchema { + name, + ty: TypeSchema::Json, + comment, + required: false, + } +} diff --git a/src/openhuman/credentials/mod.rs b/src/openhuman/credentials/mod.rs index 5fddd2332..852fbcc62 100644 --- a/src/openhuman/credentials/mod.rs +++ b/src/openhuman/credentials/mod.rs @@ -9,7 +9,7 @@ mod schemas; pub mod session_support; pub use crate::api::rest::{ - decrypt_handoff_blob, user_id_from_profile_payload, user_id_from_settings_payload, + decrypt_handoff_blob, user_id_from_auth_me_payload, user_id_from_profile_payload, BackendOAuthClient, ConnectResponse, IntegrationSummary, IntegrationTokensHandoff, }; pub use core::*; diff --git a/src/openhuman/mod.rs b/src/openhuman/mod.rs index 1077ecefc..d3501502d 100644 --- a/src/openhuman/mod.rs +++ b/src/openhuman/mod.rs @@ -14,6 +14,7 @@ pub mod about_app; pub mod accessibility; pub mod agent; +pub mod app_state; pub mod approval; pub mod autocomplete; pub mod billing; diff --git a/src/openhuman/team/ops.rs b/src/openhuman/team/ops.rs index 8ae661a14..8e6f7e659 100644 --- a/src/openhuman/team/ops.rs +++ b/src/openhuman/team/ops.rs @@ -88,6 +88,92 @@ pub async fn list_members(config: &Config, team_id: &str) -> Result Result, String> { + let data = get_authed_value(config, Method::GET, "/teams", None).await?; + Ok(RpcOutcome::single_log(data, "teams fetched from backend")) +} + +pub async fn get_team(config: &Config, team_id: &str) -> Result, String> { + let team_id = normalize_id(team_id, "teamId")?; + let path = build_api_path(&["teams", &team_id])?; + let data = get_authed_value(config, Method::GET, &path, None).await?; + Ok(RpcOutcome::single_log(data, "team fetched from backend")) +} + +#[derive(Debug, Serialize)] +struct TeamNameBody<'a> { + name: &'a str, +} + +pub async fn create_team(config: &Config, name: &str) -> Result, String> { + let trimmed = name.trim(); + if trimmed.is_empty() { + return Err("name is required".to_string()); + } + let data = get_authed_value( + config, + Method::POST, + "/teams", + Some(json!(TeamNameBody { name: trimmed })), + ) + .await?; + Ok(RpcOutcome::single_log(data, "team created via backend")) +} + +pub async fn update_team( + config: &Config, + team_id: &str, + name: Option<&str>, +) -> Result, String> { + let team_id = normalize_id(team_id, "teamId")?; + let path = build_api_path(&["teams", &team_id])?; + let mut body = serde_json::Map::new(); + if let Some(name) = name.map(str::trim).filter(|value| !value.is_empty()) { + body.insert("name".to_string(), Value::String(name.to_string())); + } + let data = get_authed_value(config, Method::PUT, &path, Some(Value::Object(body))).await?; + Ok(RpcOutcome::single_log(data, "team updated via backend")) +} + +pub async fn delete_team(config: &Config, team_id: &str) -> Result, String> { + let team_id = normalize_id(team_id, "teamId")?; + let path = build_api_path(&["teams", &team_id])?; + let data = get_authed_value(config, Method::DELETE, &path, None).await?; + Ok(RpcOutcome::single_log(data, "team deleted via backend")) +} + +pub async fn switch_team(config: &Config, team_id: &str) -> Result, String> { + let team_id = normalize_id(team_id, "teamId")?; + let path = build_api_path(&["teams", &team_id, "switch"])?; + let data = get_authed_value(config, Method::POST, &path, Some(json!({}))).await?; + Ok(RpcOutcome::single_log( + data, + "active team switched via backend", + )) +} + +pub async fn leave_team(config: &Config, team_id: &str) -> Result, String> { + let team_id = normalize_id(team_id, "teamId")?; + let path = build_api_path(&["teams", &team_id, "leave"])?; + let data = get_authed_value(config, Method::POST, &path, Some(json!({}))).await?; + Ok(RpcOutcome::single_log(data, "team left via backend")) +} + +pub async fn join_team(config: &Config, code: &str) -> Result, String> { + let trimmed = code.trim(); + if trimmed.is_empty() { + return Err("code is required".to_string()); + } + let data = get_authed_value( + config, + Method::POST, + "/teams/join", + Some(json!({ "code": trimmed })), + ) + .await?; + Ok(RpcOutcome::single_log(data, "team joined via backend")) +} + #[derive(Debug, Serialize)] #[serde(rename_all = "camelCase")] struct InviteBody { diff --git a/src/openhuman/team/schemas.rs b/src/openhuman/team/schemas.rs index 4d01f8e85..f4f27e10f 100644 --- a/src/openhuman/team/schemas.rs +++ b/src/openhuman/team/schemas.rs @@ -13,6 +13,26 @@ struct TeamIdParams { team_id: String, } +#[derive(Debug, Deserialize)] +#[serde(rename_all = "camelCase")] +struct CreateTeamParams { + name: String, +} + +#[derive(Debug, Deserialize)] +#[serde(rename_all = "camelCase")] +struct UpdateTeamParams { + team_id: String, + #[serde(default)] + name: Option, +} + +#[derive(Debug, Deserialize)] +#[serde(rename_all = "camelCase")] +struct JoinTeamParams { + code: String, +} + #[derive(Debug, Deserialize)] #[serde(rename_all = "camelCase")] struct RemoveMemberParams { @@ -49,6 +69,14 @@ pub fn all_team_controller_schemas() -> Vec { vec![ team_schemas("team_get_usage"), team_schemas("team_list_members"), + team_schemas("team_list_teams"), + team_schemas("team_get_team"), + team_schemas("team_create_team"), + team_schemas("team_update_team"), + team_schemas("team_delete_team"), + team_schemas("team_switch_team"), + team_schemas("team_leave_team"), + team_schemas("team_join_team"), team_schemas("team_create_invite"), team_schemas("team_list_invites"), team_schemas("team_revoke_invite"), @@ -67,6 +95,38 @@ pub fn all_team_registered_controllers() -> Vec { schema: team_schemas("team_list_members"), handler: handle_team_list_members, }, + RegisteredController { + schema: team_schemas("team_list_teams"), + handler: handle_team_list_teams, + }, + RegisteredController { + schema: team_schemas("team_get_team"), + handler: handle_team_get_team, + }, + RegisteredController { + schema: team_schemas("team_create_team"), + handler: handle_team_create_team, + }, + RegisteredController { + schema: team_schemas("team_update_team"), + handler: handle_team_update_team, + }, + RegisteredController { + schema: team_schemas("team_delete_team"), + handler: handle_team_delete_team, + }, + RegisteredController { + schema: team_schemas("team_switch_team"), + handler: handle_team_switch_team, + }, + RegisteredController { + schema: team_schemas("team_leave_team"), + handler: handle_team_leave_team, + }, + RegisteredController { + schema: team_schemas("team_join_team"), + handler: handle_team_join_team, + }, RegisteredController { schema: team_schemas("team_create_invite"), handler: handle_team_create_invite, @@ -114,6 +174,91 @@ pub fn team_schemas(function: &str) -> ControllerSchema { required: true, }], }, + "team_list_teams" => ControllerSchema { + namespace: "team", + function: "list_teams", + description: "List teams for the authenticated user.", + inputs: vec![], + outputs: vec![FieldSchema { + name: "result", + ty: TypeSchema::Array(Box::new(TypeSchema::Json)), + comment: "Raw team array returned by GET /teams.", + required: true, + }], + }, + "team_get_team" => ControllerSchema { + namespace: "team", + function: "get_team", + description: "Fetch a single team.", + inputs: vec![required_string("teamId", "Team id.")], + outputs: vec![json_output( + "result", + "Raw team object returned by GET /teams/:teamId.", + )], + }, + "team_create_team" => ControllerSchema { + namespace: "team", + function: "create_team", + description: "Create a team.", + inputs: vec![required_string("name", "Team name.")], + outputs: vec![json_output( + "result", + "Raw team object returned by POST /teams.", + )], + }, + "team_update_team" => ControllerSchema { + namespace: "team", + function: "update_team", + description: "Update team fields.", + inputs: vec![ + required_string("teamId", "Team id."), + optional_string("name", "Updated team name."), + ], + outputs: vec![json_output( + "result", + "Raw team object returned by PUT /teams/:teamId.", + )], + }, + "team_delete_team" => ControllerSchema { + namespace: "team", + function: "delete_team", + description: "Delete a team.", + inputs: vec![required_string("teamId", "Team id.")], + outputs: vec![json_output( + "result", + "Delete result returned by DELETE /teams/:teamId.", + )], + }, + "team_switch_team" => ControllerSchema { + namespace: "team", + function: "switch_team", + description: "Switch the active team for the current user.", + inputs: vec![required_string("teamId", "Team id.")], + outputs: vec![json_output( + "result", + "Switch result returned by POST /teams/:teamId/switch.", + )], + }, + "team_leave_team" => ControllerSchema { + namespace: "team", + function: "leave_team", + description: "Leave a team.", + inputs: vec![required_string("teamId", "Team id.")], + outputs: vec![json_output( + "result", + "Leave result returned by POST /teams/:teamId/leave.", + )], + }, + "team_join_team" => ControllerSchema { + namespace: "team", + function: "join_team", + description: "Join a team using an invite code.", + inputs: vec![required_string("code", "Invite code.")], + outputs: vec![json_output( + "result", + "Raw team object returned by POST /teams/join.", + )], + }, "team_create_invite" => ControllerSchema { namespace: "team", function: "create_invite", @@ -210,6 +355,72 @@ fn handle_team_list_members(params: Map) -> ControllerFuture { }) } +fn handle_team_list_teams(_params: Map) -> ControllerFuture { + Box::pin(async move { + let config = config_rpc::load_config_with_timeout().await?; + to_json(crate::openhuman::team::list_teams(&config).await?) + }) +} + +fn handle_team_get_team(params: Map) -> ControllerFuture { + Box::pin(async move { + let config = config_rpc::load_config_with_timeout().await?; + let payload = deserialize_params::(params)?; + to_json(crate::openhuman::team::get_team(&config, &payload.team_id).await?) + }) +} + +fn handle_team_create_team(params: Map) -> ControllerFuture { + Box::pin(async move { + let config = config_rpc::load_config_with_timeout().await?; + let payload = deserialize_params::(params)?; + to_json(crate::openhuman::team::create_team(&config, &payload.name).await?) + }) +} + +fn handle_team_update_team(params: Map) -> ControllerFuture { + Box::pin(async move { + let config = config_rpc::load_config_with_timeout().await?; + let payload = deserialize_params::(params)?; + to_json( + crate::openhuman::team::update_team(&config, &payload.team_id, payload.name.as_deref()) + .await?, + ) + }) +} + +fn handle_team_delete_team(params: Map) -> ControllerFuture { + Box::pin(async move { + let config = config_rpc::load_config_with_timeout().await?; + let payload = deserialize_params::(params)?; + to_json(crate::openhuman::team::delete_team(&config, &payload.team_id).await?) + }) +} + +fn handle_team_switch_team(params: Map) -> ControllerFuture { + Box::pin(async move { + let config = config_rpc::load_config_with_timeout().await?; + let payload = deserialize_params::(params)?; + to_json(crate::openhuman::team::switch_team(&config, &payload.team_id).await?) + }) +} + +fn handle_team_leave_team(params: Map) -> ControllerFuture { + Box::pin(async move { + let config = config_rpc::load_config_with_timeout().await?; + let payload = deserialize_params::(params)?; + to_json(crate::openhuman::team::leave_team(&config, &payload.team_id).await?) + }) +} + +fn handle_team_join_team(params: Map) -> ControllerFuture { + Box::pin(async move { + let config = config_rpc::load_config_with_timeout().await?; + let payload = deserialize_params::(params)?; + to_json(crate::openhuman::team::join_team(&config, &payload.code).await?) + }) +} + fn handle_team_create_invite(params: Map) -> ControllerFuture { Box::pin(async move { let config = config_rpc::load_config_with_timeout().await?; @@ -298,6 +509,15 @@ fn optional_u64(name: &'static str, comment: &'static str) -> FieldSchema { } } +fn optional_string(name: &'static str, comment: &'static str) -> FieldSchema { + FieldSchema { + name, + ty: TypeSchema::Option(Box::new(TypeSchema::String)), + comment, + required: false, + } +} + fn json_output(name: &'static str, comment: &'static str) -> FieldSchema { FieldSchema { name, diff --git a/tests/json_rpc_e2e.rs b/tests/json_rpc_e2e.rs index f60d7a913..c1f98b100 100644 --- a/tests/json_rpc_e2e.rs +++ b/tests/json_rpc_e2e.rs @@ -566,7 +566,7 @@ async fn json_rpc_protocol_auth_and_agent_hello() { "unexpected auth state shape: {state_body}" ); - // --- auth: store session (validates JWT via mock GET /settings) --- + // --- auth: store session (validates JWT via mock GET /auth/me) --- let store = post_json_rpc( &rpc_base, 4, diff --git a/tests/skills_notion_live.rs b/tests/skills_notion_live.rs index 1f4158bb6..112e94737 100644 --- a/tests/skills_notion_live.rs +++ b/tests/skills_notion_live.rs @@ -129,7 +129,7 @@ async fn notion_live_with_real_data() { .unwrap(); let health = client - .get(format!("{backend_url}/settings")) + .get(format!("{backend_url}/auth/me")) .header("Authorization", format!("Bearer {jwt_token}")) .send() .await; @@ -138,7 +138,7 @@ async fn notion_live_with_real_data() { Ok(resp) => { let status = resp.status(); let body = resp.text().await.unwrap_or_default(); - eprintln!(" GET /settings → HTTP {status}"); + eprintln!(" GET /auth/me → HTTP {status}"); if status.is_success() { eprintln!(" ✓ Backend reachable, JWT valid"); eprintln!(" Body: {}...", truncate_str(&body, 200));