Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。
TypeScript agentai-agentai-assistantandroidclaude-codecodexelectroniosllmmacosreact-nativetypescriptwindows
/**
* remoteSessionActivityStore —— 控制端 device-link 远程会话的实时活动镜像。
* ---------------------------------------------------------------------------
* 被控端灵动岛 relay 经 `sessions` topic 推送 `local-db:sessions:activity`
* (phase / attention / interactionKind),由 makerChatStore 的 onRemotePush 路由喂进来。
* 侧边栏远程会话行(SessionItem)右侧状态槽据此点亮与本地会话同一套指示:
* error 红点 / awaiting TapTap 蓝点 / running spinner / 完成未读绿点。
*
* 保留语义与手机端 remoteSessionStore.applySessionActivity 完全一致:
* - running / needs-interaction → 写入(活跃态)
* - completed / error 且 attention=true → 写入(未读终态;被控端真实展示后 relay
* 会重发 attention=false 的收尾包)
* - 其余(已读收尾包)→ 删除条目,行回落时间显示
*
* 不喂 dock 角标——未读归被控端。灵动岛与桌面通知由 agentIslandRemoteSessions 按侧栏
* 「任务范围」裁剪后另行同步给 main。
*
* ⚠️ 性能不变量(与 sessionAttentionStore 同款):SessionItem 逐行挂载,订阅必须是
* 按 deviceId + sessionId 的稳定引用精准订阅(条目对象未替换时快照引用不变),禁止整表订阅。
*/
import { useMemo, useSyncExternalStore } from 'react';
export type RemoteSessionActivityPhase = 'running' | 'needs-interaction' | 'completed' | 'error';
/** 镜像 @cindy/device-link 的 SessionActivityPayload(renderer 不直接依赖该包)。 */
export interface RemoteSessionActivity {
completionToken?: string;
sessionId: string;
phase: RemoteSessionActivityPhase;
compactDetail: string;
summaryFormat?: 'plain-text';
workingPhase?: string;
interactionKind?: string;
attention: boolean;
completionNotification?: 'pending' | 'teammate' | 'silent';
}
/** Active remote turns must win over the persisted "started without ended" heuristic. */
export function isRemoteSessionActivityActive(
activity: RemoteSessionActivity | undefined,
): boolean {
return activity?.phase === 'running' || activity?.phase === 'needs-interaction';
}
const listeners = new Set<(deviceId?: string, sessionId?: string) => void>();
/** deviceId → sessionId → 活动条目;本地任务没有 deviceId,不读取远程缓存。 */
const activityByDevice = new Map<string, Map<string, RemoteSessionActivity>>();
/** 整表变更版本号(聚合消费方作依赖用;activityMap 本体是可变引用,不能当快照)。 */
let revision = 0;
function emit(deviceId?: string, sessionId?: string): void {
revision++;
for (const l of listeners) l(deviceId, sessionId);
}
function isPhase(value: unknown): value is RemoteSessionActivityPhase {
return (
value === 'running' ||
value === 'needs-interaction' ||
value === 'completed' ||
value === 'error'
);
}
function sameActivity(a: RemoteSessionActivity, b: RemoteSessionActivity): boolean {
return (
a.completionToken === b.completionToken &&
a.phase === b.phase &&
a.compactDetail === b.compactDetail &&
a.summaryFormat === b.summaryFormat &&
a.workingPhase === b.workingPhase &&
a.interactionKind === b.interactionKind &&
a.completionNotification === b.completionNotification &&
a.attention === b.attention
);
}
export function subscribeRemoteSessionActivity(
listener: (deviceId?: string, sessionId?: string) => void,
): () => void {
listeners.add(listener);
return () => {
listeners.delete(listener);
};
}
export function getRemoteSessionActivity(
sessionId: string,
deviceId: string | null | undefined,
): RemoteSessionActivity | undefined {
return deviceId ? activityByDevice.get(deviceId)?.get(sessionId) : undefined;
}
/** Hook —— 按 sessionId 精准订阅(本地会话恒为 undefined,零开销)。 */
export function useRemoteSessionActivity(
sessionId: string,
deviceId: string | null | undefined,
): RemoteSessionActivity | undefined {
return useSyncExternalStore(
subscribeRemoteSessionActivity,
() => getRemoteSessionActivity(sessionId, deviceId),
() => getRemoteSessionActivity(sessionId, deviceId),
);
}
/** Hook —— 一组 sessionId 的 phase 子映射(无远程活动条目的不进结果)。
* 给"折叠容器按同一份判据汇总整组"的场景用(定时任务分组头,组内可能含
* device-link 远程运行)。快照是序列化 key(primitive),Map 由 useMemo 派生:
* 组外条目变化、以及组内 detail 类变化都不会触发重渲染 —— 别改成整表 revision
* 逐行用(会退化成整表订阅,违反文件头的性能不变量)。 */
export function useRemoteSessionsPhaseMap(
sessions: readonly { id: string; deviceLinkDeviceId?: string | null }[],
): ReadonlyMap<string, RemoteSessionActivityPhase> {
const getSnapshot = (): string => {
let key = '';
for (const { id, deviceLinkDeviceId } of sessions) {
const phase = getRemoteSessionActivity(id, deviceLinkDeviceId)?.phase;
if (phase) key += `${id}:${phase}|`;
}
return key;
};
const key = useSyncExternalStore(subscribeRemoteSessionActivity, getSnapshot, getSnapshot);
return useMemo(() => {
const map = new Map<string, RemoteSessionActivityPhase>();
for (const pair of key.split('|')) {
if (!pair) continue;
const sep = pair.lastIndexOf(':');
map.set(pair.slice(0, sep), pair.slice(sep + 1) as RemoteSessionActivityPhase);
}
return map;
}, [key]);
}
function getRevision(): number {
return revision;
}
/** Hook —— 整表版本号订阅,给**单例聚合消费方**(rail 折叠入口灯要跨全部远程
* 条目聚合)。以返回值作 memo 依赖、逐 id 用 getRemoteSessionActivity 取值。
* ⚠️ 逐行组件(SessionItem)仍必须走 useRemoteSessionActivity 精准订阅,
* 拿这个 hook 逐行用会退化成整表订阅、违反上面的性能不变量。 */
export function useRemoteSessionActivityRevision(): number {
return useSyncExternalStore(subscribeRemoteSessionActivity, getRevision, getRevision);
}
/** onRemotePush 路由入口:按上述保留语义写入 / 删除。非法 payload 静默忽略。 */
export function applyRemoteSessionActivity(deviceId: string, payload: unknown): void {
if (typeof payload !== 'object' || payload === null) return;
const p = payload as Record<string, unknown>;
const sessionId = typeof p.sessionId === 'string' ? p.sessionId : '';
if (!deviceId || !sessionId || !isPhase(p.phase)) return;
const attention = p.attention === true;
const keep = p.phase === 'running' || p.phase === 'needs-interaction' || attention;
if (!keep) {
removeRemoteSessionActivityEntry(sessionId, deviceId);
return;
}
const next: RemoteSessionActivity = {
...(typeof p.completionToken === 'string' && p.completionToken.length > 0 && p.completionToken.length <= 128
? { completionToken: p.completionToken } : {}),
sessionId,
phase: p.phase,
compactDetail: typeof p.compactDetail === 'string' ? p.compactDetail : '',
...(p.summaryFormat === 'plain-text' ? { summaryFormat: 'plain-text' as const } : {}),
workingPhase: typeof p.workingPhase === 'string' ? p.workingPhase : undefined,
interactionKind: typeof p.interactionKind === 'string' ? p.interactionKind : undefined,
attention,
completionNotification: p.completionNotification === 'pending' || p.completionNotification === 'teammate' || p.completionNotification === 'silent' ? p.completionNotification : undefined,
};
let activityMap = activityByDevice.get(deviceId);
if (!activityMap) {
activityMap = new Map();
activityByDevice.set(deviceId, activityMap);
}
const current = activityMap.get(sessionId);
if (current && sameActivity(current, next)) return;
activityMap.set(sessionId, next);
emit(deviceId, sessionId);
}
/** 刚发送时丢掉上一轮 completed/error 镜像。running / needs-interaction 是本轮活档,保留。 */
export function dropStaleRemoteTerminalActivity(
sessionId: string,
deviceId: string | null | undefined,
): void {
const activity = getRemoteSessionActivity(sessionId, deviceId);
if (!activity) return;
if (activity.phase !== 'completed' && activity.phase !== 'error') return;
removeRemoteSessionActivityEntry(sessionId, deviceId);
}
/** 单会话清除(被控端删除 / 归档该会话时由 sessions:patched 路由调用)。 */
export function removeRemoteSessionActivityEntry(
sessionId: string,
deviceId: string | null | undefined,
): void {
if (!deviceId) return;
const activityMap = activityByDevice.get(deviceId);
if (!activityMap?.delete(sessionId)) return;
if (activityMap.size === 0) activityByDevice.delete(deviceId);
emit(deviceId, sessionId);
}
/** 设备移除时只清理该设备;瞬时断线仍保留快照。 */
export function removeRemoteSessionActivityForDevice(deviceId: string): void {
if (activityByDevice.delete(deviceId)) emit(deviceId);
}
/** 全清(登出 / device-link stopped)。 */
export function clearRemoteSessionActivity(): void {
if (activityByDevice.size === 0) return;
activityByDevice.clear();
emit();
}