Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。
TypeScript agentai-agentai-assistantandroidclaude-codecodexelectroniosllmmacosreact-nativetypescriptwindows
import { useCallback, useEffect, useRef, useState } from 'react';
import { useTranslation } from 'react-i18next';
import type { RemoteResource } from '@cindy/device-link';
import { AppState } from 'react-native';
import { useFocusEffect, useIsFocused, useLocalSearchParams, useRouter } from 'expo-router';
import { useAuth } from '@/auth/AuthContext';
import { useDeviceLink } from '@/device-link/DeviceLinkContext';
import { getRemoteResource } from '@/device-link/remoteResources';
import { readRemoteCollectionCache } from '@/device-link/remoteResourceAvailability';
import { createRemoteReadRecovery } from '@/device-link/remoteReadRecovery';
import { createRemoteSyncCoordinator, retryRemoteSyncRead, type RemoteSyncRun } from '@/device-link/remoteSyncTask';
import { isAutoRecoveringRemoteError, formatRemoteError } from '@/device-link/remoteStatus';
import { forgetRemoteResource, markRemoteResourceRead } from '@/device-link/remoteResourceCache';
import { startFocusedTopicSubscription } from '@/device-link/focusedTopicSubscription';
import { remoteSessionStore } from './remoteSessionStore';
import type { RemoteSession } from './types';
import { useCachedCompanionSession } from './useCachedCompanionSession';
/** Follow a companion's current host-owned task on focus/reconnect, retaining its permanent identity. */
export function useRemoteResourceSession(deviceId: string, deviceName: string, sessionId: string, canMarkRead: boolean, metadataVerified = false) {
const params = useLocalSearchParams<{ resourceCollectionId?: string; resourceId?: string; resourceKind?: string; openSearch?: string; resourceHistorySessionId?: string }>();
const savedCompanion = useCachedCompanionSession(deviceId, sessionId);
const collectionId = typeof params.resourceCollectionId === 'string' ? params.resourceCollectionId : savedCompanion ? 'teammates' : '';
const resourceId = typeof params.resourceId === 'string' ? params.resourceId : savedCompanion?.ref.id ?? '';
const resourceKind = typeof params.resourceKind === 'string' ? params.resourceKind : savedCompanion?.ref.kind ?? '';
const historyEntry = params.openSearch === '1';
const transcriptEntry = params.resourceHistorySessionId === sessionId;
const { invoke, openLink, connectionEpoch, status, onRemoteResourceChanged, subscribe, unsubscribe } = useDeviceLink();
const { user, accountGeneration } = useAuth();
const { t, i18n } = useTranslation();
const router = useRouter();
const focused = useIsFocused();
const identity = JSON.stringify([accountGeneration, deviceId, sessionId, collectionId, resourceKind, resourceId, historyEntry, transcriptEntry]);
const [display, setDisplay] = useState<{ identity: string; resource: RemoteResource } | null>(null);
const binding = JSON.stringify([identity, connectionEpoch, i18n.language]);
const current = useRef(binding); current.current = binding;
const required = !!(collectionId && resourceId && resourceKind && deviceId);
const [verified, setVerified] = useState<string | null>(null);
const [failure, setFailure] = useState<{ binding: string; message: string } | null>(null);
const [attempt, setAttempt] = useState(0);
const retry = useCallback(() => setAttempt(value => value + 1), []);
const cached = readRemoteCollectionCache(`${user?.id ?? ''}:${accountGeneration}`, collectionId)
.find(row => row.host.deviceId === deviceId && row.item.ref.id === resourceId && row.item.ref.kind === resourceKind)?.item;
const savedMatches = savedCompanion?.ref.id === resourceId && savedCompanion.ref.kind === resourceKind && collectionId === 'teammates';
const resource = display?.identity === identity ? display.resource : cached ?? (savedMatches ? savedCompanion : null);
const stage = (display?.identity === identity
? display.resource.blocks?.find(block => block.id === 'invitation' && block.primitive === 'status')?.data as { stage?: string } | undefined
: undefined)?.stage;
const cachedTarget = resource?.links.find(link => link.rel === 'conversation')?.target;
// Local editing and durable queuing do not confer permission to dispatch.
const canCompose = !transcriptEntry && (!required || (!!resource && cachedTarget?.kind === 'session' && cachedTarget.sessionId === sessionId
&& (!stage || stage === 'ready') && (!failure || failure.binding !== binding || isAutoRecoveringRemoteError(failure.message))));
// `ready` also unlocks queued sends and runtime controls in the session screen.
const ready = !transcriptEntry && (!required || (focused && AppState.currentState === 'active' && status === 'online' && verified === binding && metadataVerified));
const markReadThrough = useCallback((at: number) => {
if (!transcriptEntry && current.current === binding && AppState.currentState === 'active' && ready && canMarkRead && resourceKind === 'bot' && resource && Number.isFinite(at) && at > 0) {
void markRemoteResourceRead(user?.id ?? '', deviceId, resourceId, Math.min(at, resource.display.lastReplyAt ?? 0));
}
}, [binding, canMarkRead, deviceId, ready, resource, resourceId, resourceKind, user?.id, transcriptEntry]);
useFocusEffect(useCallback(() => {
if (!collectionId || !resourceId || !resourceKind || !deviceId || status !== 'online') return;
setVerified(null);
let disposed = false;
let generation = 0;
let timer: ReturnType<typeof setTimeout> | undefined;
const recovery = createRemoteReadRecovery(() => { void coordinator.request({ reason: 'retry' }); },
() => !disposed && current.current === binding && AppState.currentState === 'active');
const load = async (run: RemoteSyncRun) => {
if (AppState.currentState !== 'active') return;
const expected = ++generation;
const valid = () => !run.isStale() && !disposed && current.current === binding && generation === expected && AppState.currentState === 'active';
try {
const resource = await retryRemoteSyncRead(run, async () => {
await openLink(deviceId);
return getRemoteResource(invoke, { deviceId, deviceName }, { collectionId, id: resourceId, kind: resourceKind }, i18n.language);
});
if (!valid()) return;
if (transcriptEntry) {
const profile = await retryRemoteSyncRead(run, () => invoke<{
sessions?: Array<{ id: string; role: string; status: string }>;
}>(deviceId, 'local-db:bots:get', [resourceId]));
if (!valid()) return;
if (!profile?.sessions?.some(row => row.id === sessionId && row.status !== 'deleted'
&& (row.role === 'canonical' || row.role === 'history'))) {
throw new Error(t('devices.resources.noConversation'));
}
setDisplay({ identity, resource });
setFailure(null);
setVerified(binding);
recovery.succeeded();
return;
}
// Reuse this existing read rather than issuing a second profile request per turn.
setDisplay({ identity, resource });
setFailure(null);
const stage = (resource.blocks?.find(block => block.id === 'invitation' && block.primitive === 'status')?.data as { stage?: string } | undefined)?.stage;
const invitationPending = !!stage && stage !== 'ready';
if (invitationPending && !historyEntry) {
setVerified(null);
router.replace({ pathname: '/resources/[collectionId]/[resourceId]', params: {
collectionId, resourceId, resourceKind, deviceId, deviceName,
} });
return;
}
const target = resource.links.find((link) => link.rel === 'conversation')?.target;
if (target?.kind !== 'session') throw new Error(t('devices.resources.noConversation'));
if (target.sessionId !== sessionId) {
setVerified(null);
const session = await retryRemoteSyncRead(run, () => invoke<RemoteSession>(deviceId, 'local-db:sessions:get', [target.sessionId]));
if (!valid()) return;
if (!session || session.id !== target.sessionId || (resourceKind === 'bot' && session.source !== 'bot')) throw new Error(t('devices.resources.noConversation'));
const prior = remoteSessionStore.getSessionDeviceId(session.id);
if (prior && prior !== deviceId) throw new Error(t('devices.resources.noConversation'));
remoteSessionStore.upsertDeviceSession(deviceId, deviceName, session);
router.setParams({ sessionId: session.id });
return; // The replacement task must mount and finish its own message sync first.
}
// History remains visible during preparation, but must not enable the
// composer, realtime controls or queued sends until the invitation is ready.
setVerified(invitationPending ? null : binding);
recovery.succeeded();
} catch (error) {
if (!valid()) return;
setVerified(null);
setFailure({ binding, message: formatRemoteError(error) });
recovery.failed(error);
const code = error && typeof error === 'object' ? (error as { code?: unknown }).code : undefined;
const denied = ['NOT_FOUND', 'FORBIDDEN', 'PERMISSION_DENIED', 'ACCESS_REVOKED', 'DEVICE_REVOKED'];
if (denied.includes(String(code)) || denied.some(value => String(error).includes(`[${value}]`))) {
setDisplay(null);
if (user?.id) void forgetRemoteResource(user.id, resourceId);
// A removed/hidden resource must leave the cached task view immediately.
// The resolver displays the existing unavailable/retry state.
router.replace({ pathname: '/resources/[collectionId]/[resourceId]', params: {
collectionId, resourceId, resourceKind, deviceId, deviceName,
} });
}
// Transient link errors retain the normal task recovery path.
}
};
const coordinator = createRemoteSyncCoordinator(load);
coordinator.setContext(binding);
const refresh = () => { void coordinator.request({ reason: 'changed' }); };
const offPush = onRemoteResourceChanged((source, payload) => {
if (source !== deviceId || payload.collectionId !== collectionId || timer) return;
if (payload.resourceRefs?.length && !payload.resourceRefs.some((ref) => ref.id === resourceId && ref.kind === resourceKind)) return;
generation += 1;
setVerified(null);
timer = setTimeout(() => { timer = undefined; refresh(); }, 300);
});
const offTopic = startFocusedTopicSubscription({ deviceId, owner: `resource-session:${sessionId}`, topic: 'sessions', subscribe, unsubscribe });
const appState = AppState.addEventListener('change', (state) => { generation += 1; setVerified(null); if (state === 'active') { coordinator.setContext(binding); refresh(); } else coordinator.setContext('background'); });
refresh();
return () => { disposed = true; recovery.dispose(); coordinator.setContext('disposed'); setVerified(null); offPush(); offTopic(); appState.remove(); if (timer) clearTimeout(timer); };
}, [attempt, binding, historyEntry, transcriptEntry, collectionId, deviceId, deviceName, identity, invoke, openLink, i18n.language, onRemoteResourceChanged, resourceId, resourceKind, router, sessionId, status, subscribe, t, unsubscribe, user?.id]));
return { resource, ready, canCompose, readOnly: transcriptEntry, markReadThrough, error: failure?.binding === binding ? failure.message : null, retry };
}