1470 lines
47 KiB
TypeScript
1470 lines
47 KiB
TypeScript
import type {
|
||
AiAccountRole,
|
||
AiProvider,
|
||
AiAccountStatus,
|
||
AppLogEntry,
|
||
AuthSession,
|
||
AuditTaskRequest,
|
||
AuditTaskResult,
|
||
BossState,
|
||
Capability,
|
||
ContextBudgetLevel,
|
||
Device,
|
||
DeviceEnrollment,
|
||
DeviceImportDraft,
|
||
DeviceImportResolution,
|
||
ProjectExecutionPolicy,
|
||
DeviceSkill,
|
||
MasterIdentitySummary,
|
||
MasterAgentMemory,
|
||
MasterAgentPromptPolicy,
|
||
OpsFault,
|
||
OpsRepairTicket,
|
||
OpsRepairVerification,
|
||
Project,
|
||
ProjectAgentControls,
|
||
RiskLevel,
|
||
ThreadContextAlert,
|
||
ThreadContextSnapshot,
|
||
ThreadHandoffPackage,
|
||
UserMasterPrompt,
|
||
} from "@/lib/boss-data";
|
||
import {
|
||
canAccessDevice,
|
||
canAccessProject,
|
||
canViewSkill,
|
||
filterDevicesForSession,
|
||
filterProjectDevicesForSession,
|
||
filterProjectsForSession,
|
||
type PermissionSession,
|
||
} from "@/lib/boss-permissions";
|
||
|
||
export interface ContextIndicator {
|
||
visible: boolean;
|
||
style: "ring_percent";
|
||
percent?: number;
|
||
level?: ContextBudgetLevel;
|
||
}
|
||
|
||
export interface ConversationItem {
|
||
conversationId: string;
|
||
conversationType: "master_agent" | "single_device" | "group" | "folder_archive";
|
||
projectId: string;
|
||
projectTitle: string;
|
||
threadTitle: string;
|
||
folderLabel: string;
|
||
folderKey?: string;
|
||
threadCount?: number;
|
||
searchAliases?: string[];
|
||
searchTargetProjectIds?: string[];
|
||
preview: string;
|
||
lastMessagePreview: string;
|
||
activityIconCount: number;
|
||
topPinnedLabel?: "置顶";
|
||
manualPinned: boolean;
|
||
latestReplyAt: string;
|
||
latestReplyLabel: string;
|
||
unreadCount: number;
|
||
riskLevel: RiskLevel;
|
||
activeDeviceCount: number;
|
||
deviceNamesPreview: string[];
|
||
avatar: {
|
||
primary: string;
|
||
secondary?: string;
|
||
overflowCount?: number;
|
||
};
|
||
groupMembers?: Array<{
|
||
threadId: string;
|
||
avatar: string;
|
||
title: string;
|
||
}>;
|
||
contextBudgetIndicator: ContextIndicator;
|
||
contextBudgetSourceNodeId?: string;
|
||
contextBudgetUpdatedAt?: string;
|
||
mustFinishBeforeCompaction: boolean;
|
||
}
|
||
|
||
function conversationHistoryWasCleared(state: BossState) {
|
||
return Boolean(state.conversationHistoryClearedAt?.trim());
|
||
}
|
||
|
||
export interface ThreadContextView {
|
||
snapshot: ThreadContextSnapshot;
|
||
handoffPackage?: ThreadHandoffPackage;
|
||
alerts: ThreadContextAlert[];
|
||
}
|
||
|
||
export interface ProjectDetailView {
|
||
project: Project;
|
||
agentControls?: ProjectAgentControls | null;
|
||
devices: Device[];
|
||
masterIdentity?: MasterIdentitySummary;
|
||
activeThreadContexts: ThreadContextView[];
|
||
nextCompactionRiskThreadId?: string;
|
||
threadsRequiringHandoff: ThreadContextView[];
|
||
masterContextStrategySummary: string;
|
||
recentAppLogs: AppLogEntry[];
|
||
openFaults: OpsFault[];
|
||
relatedAuditResults: AuditTaskResult[];
|
||
}
|
||
|
||
export interface ThreadContextDetailView {
|
||
snapshot: ThreadContextSnapshot;
|
||
handoffPackage?: ThreadHandoffPackage;
|
||
alerts: ThreadContextAlert[];
|
||
currentChecklist: string[];
|
||
masterActions: string[];
|
||
}
|
||
|
||
export interface DeviceWorkspaceView {
|
||
selectedDevice?: Device;
|
||
relatedThreads: ThreadContextSnapshot[];
|
||
activeEnrollment?: DeviceEnrollment;
|
||
importDraft?: DeviceImportDraft;
|
||
importResolution?: DeviceImportResolution;
|
||
projectExecutionPolicies?: ProjectExecutionPolicy[];
|
||
}
|
||
|
||
export interface OpsSummaryView {
|
||
mode: "active" | "idle";
|
||
faults: OpsFault[];
|
||
tickets: Array<
|
||
OpsRepairTicket & {
|
||
verification?: OpsRepairVerification;
|
||
}
|
||
>;
|
||
}
|
||
|
||
export interface AuditSummaryView {
|
||
pendingRequests: AuditTaskRequest[];
|
||
latestResults: AuditTaskResult[];
|
||
capabilities: Capability[];
|
||
}
|
||
|
||
export interface SkillInventoryDeviceGroup {
|
||
device: Device;
|
||
skills: DeviceSkill[];
|
||
}
|
||
|
||
export interface SkillInventoryView {
|
||
boundDeviceId?: string;
|
||
groups: SkillInventoryDeviceGroup[];
|
||
}
|
||
|
||
const levelPriority: Record<ContextBudgetLevel, number> = {
|
||
critical: 0,
|
||
urgent: 1,
|
||
watch: 2,
|
||
safe: 3,
|
||
};
|
||
|
||
const aiRolePriority: Record<AiAccountRole, number> = {
|
||
primary: 0,
|
||
backup: 1,
|
||
api_fallback: 2,
|
||
};
|
||
|
||
const shanghaiFormatter = new Intl.DateTimeFormat("zh-CN", {
|
||
timeZone: "Asia/Shanghai",
|
||
hour: "2-digit",
|
||
minute: "2-digit",
|
||
hour12: false,
|
||
});
|
||
|
||
const shanghaiDayFormatter = new Intl.DateTimeFormat("zh-CN", {
|
||
timeZone: "Asia/Shanghai",
|
||
month: "2-digit",
|
||
day: "2-digit",
|
||
hour: "2-digit",
|
||
minute: "2-digit",
|
||
hour12: false,
|
||
});
|
||
|
||
export function formatTimestampLabel(value?: string, fallback = "刚刚") {
|
||
if (!value) return fallback;
|
||
if (!value.includes("T")) return value;
|
||
const date = new Date(value);
|
||
if (Number.isNaN(date.getTime())) return value;
|
||
|
||
const diff = Date.now() - date.getTime();
|
||
if (Math.abs(diff) < 60_000) return "刚刚";
|
||
if (diff >= 0 && diff < 24 * 60 * 60_000) {
|
||
return shanghaiFormatter.format(date);
|
||
}
|
||
return shanghaiDayFormatter.format(date);
|
||
}
|
||
|
||
const STALE_CONTEXT_SYNC_LABEL = "待同步";
|
||
const STALE_CONTEXT_REPLY_THRESHOLD_MS = 7 * 24 * 60 * 60_000;
|
||
const PROCESS_PREVIEW_PREFIXES = [
|
||
"我先",
|
||
"我现在",
|
||
"我会先",
|
||
"我发现",
|
||
"我准备",
|
||
"接下来",
|
||
"正在",
|
||
"先看",
|
||
"先读",
|
||
"我把",
|
||
"我再",
|
||
"目前在",
|
||
"现在在",
|
||
"补一组",
|
||
"处理一下",
|
||
"先确认",
|
||
"准备",
|
||
"同步一下",
|
||
"我这边已经",
|
||
];
|
||
const PROCESS_PREVIEW_CONTAINS = [
|
||
"我继续",
|
||
"我已经在",
|
||
"正在跑",
|
||
"正在检查",
|
||
"正在处理",
|
||
"正在同步",
|
||
"我会直接",
|
||
"我先把",
|
||
"先补",
|
||
"再接",
|
||
];
|
||
const PROCESS_PREVIEW_NUMBERED_HINTS = [
|
||
"先",
|
||
"再",
|
||
"接下来",
|
||
"然后",
|
||
"检查",
|
||
"确认",
|
||
"处理",
|
||
"同步",
|
||
"补",
|
||
"排查",
|
||
"推进",
|
||
"回你",
|
||
"回传",
|
||
"会把",
|
||
"我会",
|
||
];
|
||
const PROCESS_PREVIEW_BLOCK_MARKERS = [
|
||
"失败",
|
||
"报错",
|
||
"错误",
|
||
"阻塞",
|
||
"不能",
|
||
"无法",
|
||
"崩溃",
|
||
"超时",
|
||
"exception",
|
||
"error",
|
||
"fatal",
|
||
"结论",
|
||
"最终",
|
||
"总结",
|
||
"已完成",
|
||
"已经完成",
|
||
"验证通过",
|
||
"测试通过",
|
||
"已修复",
|
||
"修好了",
|
||
"已部署",
|
||
"已安装",
|
||
"可以直接",
|
||
];
|
||
const LEAKED_TITLE_PREFIXES = [
|
||
"你当前接手的项目根目录是",
|
||
"你现在接手的项目根目录是",
|
||
"你现在以目标线程身份直接回复用户",
|
||
"你正在向主 Agent 同步当前项目状态",
|
||
"只回复对用户真正有用的内容",
|
||
"只输出 JSON",
|
||
];
|
||
const LEAKED_TITLE_CONTAINS = [
|
||
"不要发送内部字段",
|
||
"不要自称主 Agent",
|
||
"不要解释系统如何分发",
|
||
"不要输出 JSON",
|
||
"项目名称：",
|
||
"线程名称：",
|
||
"文件夹：",
|
||
"同步原因：",
|
||
"当前消息：",
|
||
"用户当前消息：",
|
||
];
|
||
|
||
function formatConversationLatestReplyLabel(value: string, hasVisibleContext: boolean) {
|
||
if (hasVisibleContext && value.includes("T")) {
|
||
const date = new Date(value);
|
||
const diff = Date.now() - date.getTime();
|
||
if (!Number.isNaN(date.getTime()) && diff >= STALE_CONTEXT_REPLY_THRESHOLD_MS) {
|
||
return STALE_CONTEXT_SYNC_LABEL;
|
||
}
|
||
}
|
||
return formatTimestampLabel(value);
|
||
}
|
||
|
||
function compareSnapshots(a: ThreadContextSnapshot, b: ThreadContextSnapshot) {
|
||
if (a.mustFinishBeforeCompaction !== b.mustFinishBeforeCompaction) {
|
||
return a.mustFinishBeforeCompaction ? -1 : 1;
|
||
}
|
||
if (levelPriority[a.contextBudgetLevel] !== levelPriority[b.contextBudgetLevel]) {
|
||
return levelPriority[a.contextBudgetLevel] - levelPriority[b.contextBudgetLevel];
|
||
}
|
||
return (a.compactionExpectedAt ?? "").localeCompare(b.compactionExpectedAt ?? "");
|
||
}
|
||
|
||
function projectType(project: Project): ConversationItem["conversationType"] {
|
||
if (project.id === "master-agent") return "master_agent";
|
||
return project.isGroup ? "group" : "single_device";
|
||
}
|
||
|
||
function buildFolderKey(project: Project) {
|
||
if (project.id === "master-agent" || project.isGroup) return undefined;
|
||
const deviceId = project.deviceIds[0];
|
||
const folderRef = (project.threadMeta.codexFolderRef?.trim() || project.threadMeta.folderName.trim()).toLowerCase();
|
||
if (!deviceId || !folderRef) return undefined;
|
||
return `${deviceId}:${folderRef}`;
|
||
}
|
||
|
||
function isTopPinnedConversation(project: Project) {
|
||
return Boolean(project.pinned || project.systemPinned || project.id === "audit-collab");
|
||
}
|
||
|
||
function getThreadAvatarFallback(title: string) {
|
||
const trimmed = title.trim();
|
||
if (!trimmed) return "A";
|
||
return trimmed.slice(0, 1).toUpperCase();
|
||
}
|
||
|
||
function getGroupMemberAvatar(member: Project["groupMembers"][number], device?: Device) {
|
||
const avatar = device?.avatar?.trim();
|
||
if (avatar) return avatar;
|
||
return getThreadAvatarFallback(member.threadDisplayName);
|
||
}
|
||
|
||
function aiRoleLabel(role: AiAccountRole) {
|
||
switch (role) {
|
||
case "primary":
|
||
return "主 GPT";
|
||
case "backup":
|
||
return "备用 GPT";
|
||
case "api_fallback":
|
||
return "API 容灾";
|
||
default:
|
||
return role;
|
||
}
|
||
}
|
||
|
||
function aiProviderLabel(provider: AiProvider) {
|
||
switch (provider) {
|
||
case "master_codex_node":
|
||
return "Master Codex Node";
|
||
case "openai_api":
|
||
return "OpenAI API";
|
||
case "aliyun_qwen_api":
|
||
return "阿里百炼 Qwen";
|
||
case "deepseek_api":
|
||
return "DeepSeek API";
|
||
default:
|
||
return provider;
|
||
}
|
||
}
|
||
|
||
function aiStatusLabel(status: AiAccountStatus) {
|
||
switch (status) {
|
||
case "ready":
|
||
return "可用";
|
||
case "needs_login":
|
||
return "待登录";
|
||
case "needs_api_key":
|
||
return "待配置 Key";
|
||
case "degraded":
|
||
return "异常";
|
||
case "disabled":
|
||
return "已停用";
|
||
default:
|
||
return status;
|
||
}
|
||
}
|
||
|
||
function canGenerateAiAccount(account: BossState["aiAccounts"][number]) {
|
||
if (!account.enabled) return false;
|
||
if (account.provider === "master_codex_node") {
|
||
return Boolean(account.nodeId?.trim());
|
||
}
|
||
return Boolean(account.apiKey?.trim());
|
||
}
|
||
|
||
function getProjectMasterIdentity(state: BossState): MasterIdentitySummary {
|
||
const accounts = [...state.aiAccounts].sort((a, b) => {
|
||
if (a.isActive !== b.isActive) return a.isActive ? -1 : 1;
|
||
if (aiRolePriority[a.role] !== aiRolePriority[b.role]) {
|
||
return aiRolePriority[a.role] - aiRolePriority[b.role];
|
||
}
|
||
return (b.updatedAt ?? "").localeCompare(a.updatedAt ?? "");
|
||
});
|
||
const account = accounts.find((item) => item.isActive) ?? accounts.find(canGenerateAiAccount) ?? accounts[0];
|
||
|
||
if (!account) {
|
||
return {
|
||
label: "API 容灾",
|
||
role: "api_fallback",
|
||
roleLabel: aiRoleLabel("api_fallback"),
|
||
provider: "openai_api",
|
||
providerLabel: aiProviderLabel("openai_api"),
|
||
displayName: "未配置 AI 账号",
|
||
status: "needs_api_key",
|
||
statusLabel: aiStatusLabel("needs_api_key"),
|
||
canGenerate: false,
|
||
note: "请到“我的 > AI 账号”补齐主控 AI 账号。",
|
||
};
|
||
}
|
||
|
||
return {
|
||
accountId: account.accountId,
|
||
label: account.label,
|
||
role: account.role,
|
||
roleLabel: aiRoleLabel(account.role),
|
||
provider: account.provider,
|
||
providerLabel: aiProviderLabel(account.provider),
|
||
displayName: account.displayName,
|
||
nodeLabel: account.nodeLabel,
|
||
model: account.model,
|
||
status: account.status,
|
||
statusLabel: aiStatusLabel(account.status),
|
||
canGenerate: canGenerateAiAccount(account),
|
||
switchReason: account.switchReason,
|
||
lastSwitchedAt: account.lastSwitchedAt,
|
||
note: account.loginStatusNote,
|
||
};
|
||
}
|
||
|
||
export function getMasterAgentPromptPolicyView(state: BossState): MasterAgentPromptPolicy | null {
|
||
return state.masterAgentPromptPolicy ?? null;
|
||
}
|
||
|
||
export function getUserMasterPromptView(state: BossState, account: string): UserMasterPrompt | null {
|
||
return state.userMasterPrompts.find((item) => item.account === account) ?? null;
|
||
}
|
||
|
||
export function listUserMasterMemoriesView(
|
||
state: BossState,
|
||
account: string,
|
||
options?: { includeArchived?: boolean },
|
||
): MasterAgentMemory[] {
|
||
const includeArchived = options?.includeArchived ?? false;
|
||
return [...state.masterAgentMemories]
|
||
.filter((memory) => memory.account === account && (includeArchived || !memory.archived))
|
||
.sort((a, b) => {
|
||
const aTime = Date.parse(a.lastUsedAt ?? a.updatedAt ?? a.createdAt) || 0;
|
||
const bTime = Date.parse(b.lastUsedAt ?? b.updatedAt ?? b.createdAt) || 0;
|
||
if (aTime !== bTime) return bTime - aTime;
|
||
return b.memoryId.localeCompare(a.memoryId);
|
||
});
|
||
}
|
||
|
||
function threadViewsForProject(state: BossState, projectId: string) {
|
||
return state.threadContextSnapshots
|
||
.filter((snapshot) => snapshot.projectId === projectId)
|
||
.sort(compareSnapshots)
|
||
.map((snapshot) => ({
|
||
snapshot,
|
||
handoffPackage: state.threadHandoffPackages.find(
|
||
(item) => item.fromThreadId === snapshot.threadId && item.packageStatus !== "expired",
|
||
),
|
||
alerts: state.threadContextAlerts.filter((alert) => alert.threadId === snapshot.threadId),
|
||
}));
|
||
}
|
||
|
||
function buildConversationItem(state: BossState, project: Project): ConversationItem {
|
||
const devices = state.devices.filter((device) => project.deviceIds.includes(device.id));
|
||
const threadViews = threadViewsForProject(state, project.id);
|
||
const topThread = threadViews[0]?.snapshot;
|
||
const { folderLabel, threadTitle, projectTitle } = buildProjectDisplayTitles(project);
|
||
const activityIconCount = deriveConversationActivityIconCount(state, project);
|
||
const topPinnedLabel = isTopPinnedConversation(project) ? "置顶" : undefined;
|
||
const latestConversationActivityAt = deriveLatestConversationActivityAt(project);
|
||
const compactPreview = compactImportedThreadPreview(project.preview);
|
||
const groupMembers = project.isGroup
|
||
? project.groupMembers.map((member) => ({
|
||
threadId: member.threadId,
|
||
avatar: getGroupMemberAvatar(
|
||
member,
|
||
state.devices.find((device) => device.id === member.deviceId),
|
||
),
|
||
title: member.threadDisplayName,
|
||
}))
|
||
: undefined;
|
||
|
||
return {
|
||
conversationId: `conv-${project.id}`,
|
||
conversationType: projectType(project),
|
||
projectId: project.id,
|
||
projectTitle,
|
||
threadTitle,
|
||
folderLabel,
|
||
folderKey: buildFolderKey(project),
|
||
preview: compactPreview,
|
||
lastMessagePreview: compactPreview,
|
||
activityIconCount,
|
||
topPinnedLabel,
|
||
manualPinned: Boolean(project.pinned && !project.systemPinned),
|
||
latestReplyAt: latestConversationActivityAt,
|
||
latestReplyLabel: formatConversationLatestReplyLabel(
|
||
latestConversationActivityAt,
|
||
Boolean(topThread),
|
||
),
|
||
unreadCount: project.unreadCount,
|
||
riskLevel: project.riskLevel,
|
||
activeDeviceCount: devices.length,
|
||
deviceNamesPreview: devices.map((device) => device.name),
|
||
avatar: {
|
||
primary: devices[0]?.avatar ?? "A",
|
||
secondary: project.isGroup ? devices[1]?.avatar : undefined,
|
||
overflowCount: Math.max(0, devices.length - 2) || undefined,
|
||
},
|
||
groupMembers,
|
||
contextBudgetIndicator: {
|
||
visible: Boolean(topThread),
|
||
style: "ring_percent",
|
||
percent: topThread?.contextBudgetRemainingPct,
|
||
level: topThread?.contextBudgetLevel,
|
||
},
|
||
contextBudgetSourceNodeId: topThread?.nodeId,
|
||
contextBudgetUpdatedAt: topThread?.capturedAt,
|
||
mustFinishBeforeCompaction: Boolean(topThread?.mustFinishBeforeCompaction),
|
||
} satisfies ConversationItem;
|
||
}
|
||
|
||
function buildProjectDisplayTitles(project: Project) {
|
||
const folderLabel = normalizeConversationTitle(project.threadMeta?.folderName ?? "");
|
||
const folderFallback = pickConversationTitleFallback([
|
||
folderLabel,
|
||
project.threadMeta?.codexFolderRef,
|
||
project.name,
|
||
]);
|
||
const threadTitle = sanitizeConversationTitle(project.threadMeta?.threadDisplayName ?? project.name, [
|
||
folderFallback,
|
||
project.name,
|
||
project.threadMeta?.codexFolderRef,
|
||
]);
|
||
const projectTitle = projectType(project) === "single_device"
|
||
? threadTitle ||
|
||
sanitizeConversationTitle(project.name, [folderFallback, project.threadMeta?.codexFolderRef])
|
||
: sanitizeConversationTitle(project.name, [
|
||
threadTitle,
|
||
folderFallback,
|
||
project.threadMeta?.codexFolderRef,
|
||
]);
|
||
return {
|
||
folderLabel,
|
||
threadTitle,
|
||
projectTitle,
|
||
};
|
||
}
|
||
|
||
function cloneProjectWithDisplayTitles(project: Project): Project {
|
||
const { folderLabel, threadTitle, projectTitle } = buildProjectDisplayTitles(project);
|
||
return {
|
||
...project,
|
||
name: projectTitle || project.name,
|
||
threadMeta: {
|
||
...project.threadMeta,
|
||
threadDisplayName: threadTitle || project.threadMeta.threadDisplayName,
|
||
folderName: folderLabel || project.threadMeta.folderName,
|
||
},
|
||
};
|
||
}
|
||
|
||
function deriveLatestConversationActivityAt(project: Project) {
|
||
const messageCandidates = [
|
||
project.lastMessageAt,
|
||
...project.messages.map((message) => message.sentAt),
|
||
].filter(Boolean) as string[];
|
||
|
||
let latest = messageCandidates[0];
|
||
let latestTs = latest ? Date.parse(latest) : Number.NEGATIVE_INFINITY;
|
||
|
||
for (const candidate of messageCandidates.slice(1)) {
|
||
const candidateTs = Date.parse(candidate);
|
||
if (!Number.isFinite(candidateTs)) {
|
||
continue;
|
||
}
|
||
if (!Number.isFinite(latestTs) || candidateTs > latestTs) {
|
||
latest = candidate;
|
||
latestTs = candidateTs;
|
||
}
|
||
}
|
||
|
||
return latest ?? project.lastMessageAt ?? project.updatedAt;
|
||
}
|
||
|
||
function deriveConversationActivityIconCount(state: BossState, project: Project): number {
|
||
let count = 0;
|
||
|
||
if (
|
||
state.dispatchPlans.some(
|
||
(plan) => plan.groupProjectId === project.id && plan.status === "pending_user_confirmation",
|
||
)
|
||
) {
|
||
count += 1;
|
||
}
|
||
|
||
count += state.dispatchExecutions.filter(
|
||
(execution) =>
|
||
(execution.groupProjectId === project.id || execution.targetProjectId === project.id) &&
|
||
(execution.status === "queued" || execution.status === "running"),
|
||
).length;
|
||
|
||
count += state.masterAgentTasks.filter(
|
||
(task) =>
|
||
task.projectId === project.id &&
|
||
task.taskType !== "device_import_resolution" &&
|
||
(task.status === "queued" || task.status === "running"),
|
||
).length;
|
||
|
||
return Math.max(0, Math.min(4, count));
|
||
}
|
||
|
||
function sortConversationItems(items: ConversationItem[]) {
|
||
return items.sort((a, b) => {
|
||
if (a.projectId === "master-agent") return -1;
|
||
if (b.projectId === "master-agent") return 1;
|
||
const aPinned = Boolean(a.topPinnedLabel);
|
||
const bPinned = Boolean(b.topPinnedLabel);
|
||
if (aPinned !== bPinned) return aPinned ? -1 : 1;
|
||
return b.latestReplyAt.localeCompare(a.latestReplyAt);
|
||
});
|
||
}
|
||
|
||
function buildFolderSearchAliases(items: ConversationItem[]) {
|
||
const aliases: string[] = [];
|
||
const targetProjectIds: string[] = [];
|
||
for (const item of items) {
|
||
const alias = (item.threadTitle?.trim() || item.projectTitle?.trim() || "").trim();
|
||
if (!alias) continue;
|
||
aliases.push(alias);
|
||
targetProjectIds.push(item.projectId);
|
||
}
|
||
return aliases.length > 0
|
||
? {
|
||
aliases,
|
||
targetProjectIds,
|
||
}
|
||
: undefined;
|
||
}
|
||
|
||
function compactImportedThreadPreview(preview?: string) {
|
||
const value = preview?.trim();
|
||
if (!value) return "";
|
||
if (/^已从设备.+导入线程《.+》[。.]?$/.test(value)) {
|
||
return "已导入线程";
|
||
}
|
||
if (isLikelyProcessPreview(value)) {
|
||
return "";
|
||
}
|
||
return compactConversationPreview(value);
|
||
}
|
||
|
||
function isLikelyProcessPreview(preview: string) {
|
||
const normalized = compactProcessPreview(preview);
|
||
if (!normalized) {
|
||
return false;
|
||
}
|
||
if (containsProcessPreviewMarker(normalized, PROCESS_PREVIEW_BLOCK_MARKERS)) {
|
||
return false;
|
||
}
|
||
if (isStructuredNumberedProcessPreview(preview)) {
|
||
return true;
|
||
}
|
||
return (
|
||
PROCESS_PREVIEW_PREFIXES.some((marker) => normalized.startsWith(marker)) ||
|
||
containsProcessPreviewMarker(normalized, PROCESS_PREVIEW_CONTAINS)
|
||
);
|
||
}
|
||
|
||
function compactProcessPreview(value: string) {
|
||
return value
|
||
.replace(/\r\n/g, "\n")
|
||
.replace(/\r/g, "\n")
|
||
.replace(/\n{2,}/g, "\n")
|
||
.trim()
|
||
.toLowerCase();
|
||
}
|
||
|
||
function containsProcessPreviewMarker(value: string, markers: string[]) {
|
||
return markers.some((marker) => value.includes(marker));
|
||
}
|
||
|
||
function isStructuredNumberedProcessPreview(preview: string) {
|
||
const numberedLines = preview
|
||
.replace(/\r\n/g, "\n")
|
||
.replace(/\r/g, "\n")
|
||
.split("\n")
|
||
.map((line) => compactProcessPreview(line))
|
||
.filter((line) => /^\d+[.)\u3001]\s*/.test(line));
|
||
if (numberedLines.length < 2) {
|
||
return false;
|
||
}
|
||
return containsProcessPreviewMarker(
|
||
numberedLines.join(" "),
|
||
PROCESS_PREVIEW_NUMBERED_HINTS,
|
||
);
|
||
}
|
||
|
||
function compactConversationPreview(preview: string) {
|
||
const structuredPreview = compactStructuredSummaryPreview(preview);
|
||
const flattened = (structuredPreview || preview)
|
||
.replace(/\[[^\]]+\]\(([^)]+)\)/g, "$1")
|
||
.replace(/`([^`]+)`/g, "$1")
|
||
.replace(/\s+/g, " ")
|
||
.trim();
|
||
if (!flattened) {
|
||
return "";
|
||
}
|
||
return flattened.length <= 72 ? flattened : `${flattened.slice(0, 72).trimEnd()}…`;
|
||
}
|
||
|
||
function compactStructuredSummaryPreview(preview: string) {
|
||
const raw = preview.trim();
|
||
if (!raw.startsWith("{") || !raw.endsWith("}")) {
|
||
return "";
|
||
}
|
||
try {
|
||
const parsed = JSON.parse(raw) as Record<string, unknown>;
|
||
if (!parsed || Array.isArray(parsed)) {
|
||
return "";
|
||
}
|
||
const segments = [
|
||
formatStructuredSummarySegment("目标", parsed.projectGoal),
|
||
formatStructuredSummarySegment("进度", parsed.currentProgress),
|
||
formatStructuredSummarySegment("版本", parsed.versionRecord),
|
||
formatStructuredSummarySegment("下一步", parsed.recommendedNextStep),
|
||
].filter(Boolean);
|
||
return segments.join(" ");
|
||
} catch {
|
||
return "";
|
||
}
|
||
}
|
||
|
||
function formatStructuredSummarySegment(label: string, value: unknown) {
|
||
const normalized = typeof value === "string" ? value.trim() : "";
|
||
return normalized ? `${label}：${normalized}` : "";
|
||
}
|
||
|
||
function normalizeConversationTitle(value?: string) {
|
||
const source = value?.replace(/\u0000/g, "") ?? "";
|
||
const firstLine = source
|
||
.split(/\r?\n/)
|
||
.map((line) => line.trim())
|
||
.find(Boolean);
|
||
if (!firstLine) {
|
||
return "";
|
||
}
|
||
return firstLine.replace(/\s+/g, " ").trim();
|
||
}
|
||
|
||
function stripTrailingConversationTitleNoise(value: string) {
|
||
return value.replace(/['"}\]]{2,}$/g, "").trimEnd();
|
||
}
|
||
|
||
function looksLikeLeakedConversationTitle(value?: string) {
|
||
const normalized = normalizeConversationTitle(value);
|
||
if (!normalized) {
|
||
return false;
|
||
}
|
||
return (
|
||
LEAKED_TITLE_PREFIXES.some((marker) => normalized.startsWith(marker)) ||
|
||
LEAKED_TITLE_CONTAINS.some((marker) => normalized.includes(marker))
|
||
);
|
||
}
|
||
|
||
function extractWorkspaceProjectName(value?: string) {
|
||
const normalized = normalizeConversationTitle(value).replaceAll("\\", "/");
|
||
if (!normalized) {
|
||
return "";
|
||
}
|
||
const patterns = [
|
||
/\/Users\/[^/]+\/code\/([^/\s"'`，。；！？]+)/i,
|
||
/\/home\/[^/]+\/code\/([^/\s"'`，。；！？]+)/i,
|
||
/[A-Za-z]:\/Users\/[^/]+\/code\/([^/\s"'`，。；！？]+)/i,
|
||
];
|
||
for (const pattern of patterns) {
|
||
const match = normalized.match(pattern);
|
||
if (match?.[1]) {
|
||
return match[1].split("/")[0]?.trim() ?? "";
|
||
}
|
||
}
|
||
return "";
|
||
}
|
||
|
||
function pickConversationTitleFallback(candidates: Array<string | undefined>) {
|
||
for (const candidate of candidates) {
|
||
const extractedProjectName = extractWorkspaceProjectName(candidate);
|
||
if (extractedProjectName && !looksLikeLeakedConversationTitle(extractedProjectName)) {
|
||
return extractedProjectName;
|
||
}
|
||
const normalized = stripTrailingConversationTitleNoise(
|
||
trimLocalWorkspacePrefix(normalizeConversationTitle(candidate)),
|
||
);
|
||
if (normalized && !looksLikeLeakedConversationTitle(normalized)) {
|
||
return normalized;
|
||
}
|
||
}
|
||
return "";
|
||
}
|
||
|
||
function sanitizeConversationTitle(value: string | undefined, fallbackCandidates: Array<string | undefined> = []) {
|
||
const normalized = normalizeConversationTitle(value);
|
||
const trimmed = stripTrailingConversationTitleNoise(trimLocalWorkspacePrefix(normalized));
|
||
if (trimmed && !looksLikeLeakedConversationTitle(normalized) && !looksLikeLeakedConversationTitle(trimmed)) {
|
||
return trimmed;
|
||
}
|
||
|
||
const extractedProjectName = extractWorkspaceProjectName(normalized);
|
||
if (extractedProjectName && !looksLikeLeakedConversationTitle(extractedProjectName)) {
|
||
return extractedProjectName;
|
||
}
|
||
|
||
const fallback = pickConversationTitleFallback(fallbackCandidates);
|
||
return fallback || trimmed;
|
||
}
|
||
|
||
function trimLocalWorkspacePrefix(label?: string) {
|
||
const value = label?.trim();
|
||
if (!value) return "";
|
||
const normalized = value.replaceAll("\\", "/");
|
||
const patterns = [
|
||
/^\/Users\/[^/]+\/code\/(.+)$/i,
|
||
/^\/home\/[^/]+\/code\/(.+)$/i,
|
||
/^[A-Za-z]:\/Users\/[^/]+\/code\/(.+)$/i,
|
||
];
|
||
for (const pattern of patterns) {
|
||
const match = normalized.match(pattern);
|
||
if (match?.[1]) {
|
||
return match[1];
|
||
}
|
||
}
|
||
return value;
|
||
}
|
||
|
||
export function getConversationItems(state: BossState): ConversationItem[] {
|
||
const conversations = state.projects.map((project) => buildConversationItem(state, project));
|
||
|
||
return sortConversationItems(conversations);
|
||
}
|
||
|
||
function stateForSession(state: BossState, session: PermissionSession): BossState {
|
||
const visibleDevices = filterDevicesForSession(state, session);
|
||
const visibleDeviceIds = new Set(visibleDevices.map((device) => device.id));
|
||
const visibleProjects = filterProjectsForSession(state, session).map((project) => ({
|
||
...project,
|
||
deviceIds: project.deviceIds.filter((deviceId) => visibleDeviceIds.has(deviceId)),
|
||
groupMembers: project.groupMembers.filter((member) => visibleDeviceIds.has(member.deviceId)),
|
||
}));
|
||
const scopedVisibleProjects = visibleProjects.map((project) =>
|
||
project.id === "master-agent" && session.role !== "highest_admin"
|
||
? projectWithAccountScopedMasterMessages(project, session.account)
|
||
: project,
|
||
);
|
||
const visibleProjectIds = new Set(scopedVisibleProjects.map((project) => project.id));
|
||
const canSeeThreadOnDevice = (projectId: string, deviceId: string) =>
|
||
visibleProjectIds.has(projectId) && visibleDeviceIds.has(deviceId);
|
||
return {
|
||
...state,
|
||
devices: visibleDevices,
|
||
projects: scopedVisibleProjects,
|
||
deviceSkills: state.deviceSkills.filter((skill) =>
|
||
visibleDeviceIds.has(skill.deviceId) &&
|
||
(session.role === "highest_admin" ||
|
||
canViewSkill(state, session, skill.skillId, { deviceId: skill.deviceId })),
|
||
),
|
||
threadStatusDocuments: state.threadStatusDocuments.filter((document) =>
|
||
canSeeThreadOnDevice(document.projectId, document.deviceId),
|
||
),
|
||
threadProgressEvents: state.threadProgressEvents.filter((event) =>
|
||
canSeeThreadOnDevice(event.projectId, event.deviceId),
|
||
),
|
||
threadContextSnapshots: state.threadContextSnapshots.filter((snapshot) =>
|
||
canSeeThreadOnDevice(snapshot.projectId, snapshot.nodeId),
|
||
),
|
||
threadHandoffPackages: state.threadHandoffPackages.filter((item) =>
|
||
visibleProjectIds.has(item.projectId),
|
||
),
|
||
threadContextAlerts: state.threadContextAlerts.filter((alert) =>
|
||
visibleProjectIds.has(alert.projectId),
|
||
),
|
||
dispatchPlans: state.dispatchPlans
|
||
.filter((plan) => visibleProjectIds.has(plan.groupProjectId))
|
||
.map((plan) => ({
|
||
...plan,
|
||
targets: plan.targets.filter(
|
||
(target) =>
|
||
visibleProjectIds.has(target.projectId) &&
|
||
visibleDeviceIds.has(target.deviceId),
|
||
),
|
||
confirmedTargetProjectIds: plan.confirmedTargetProjectIds?.filter((projectId) =>
|
||
visibleProjectIds.has(projectId),
|
||
),
|
||
})),
|
||
dispatchExecutions: state.dispatchExecutions.filter(
|
||
(execution) =>
|
||
visibleProjectIds.has(execution.groupProjectId) &&
|
||
visibleProjectIds.has(execution.targetProjectId) &&
|
||
visibleDeviceIds.has(execution.deviceId),
|
||
),
|
||
masterAgentTasks: state.masterAgentTasks.filter(
|
||
(task) =>
|
||
task.requestedByAccount === session.account ||
|
||
visibleProjectIds.has(task.projectId) ||
|
||
Boolean(task.targetProjectId && visibleProjectIds.has(task.targetProjectId)),
|
||
),
|
||
appLogs: state.appLogs.filter((log) =>
|
||
visibleDeviceIds.has(log.deviceId) ||
|
||
Boolean(log.projectId && visibleProjectIds.has(log.projectId)),
|
||
),
|
||
};
|
||
}
|
||
|
||
function projectWithAccountScopedMasterMessages(project: Project, account: string): Project {
|
||
const messages = project.messages.filter((message) => message.account === account);
|
||
const latestMessage = [...messages].sort(
|
||
(left, right) => Date.parse(right.sentAt) - Date.parse(left.sentAt),
|
||
)[0];
|
||
return {
|
||
...project,
|
||
messages,
|
||
preview: latestMessage?.body ?? "",
|
||
lastMessageAt: latestMessage?.sentAt ?? project.updatedAt,
|
||
unreadCount: messages.filter((message) => message.sender !== "user").length,
|
||
};
|
||
}
|
||
|
||
export function getAuthorizedStateSnapshot(
|
||
state: BossState,
|
||
session: Pick<AuthSession, "account" | "role" | "displayName">,
|
||
): BossState {
|
||
return stateForSession(state, session);
|
||
}
|
||
|
||
export function getConversationItemsForSession(
|
||
state: BossState,
|
||
session: Pick<AuthSession, "account" | "role" | "displayName">,
|
||
): ConversationItem[] {
|
||
return getConversationItems(stateForSession(state, session));
|
||
}
|
||
|
||
export interface ConversationFolderView {
|
||
folderKey: string;
|
||
folderLabel: string;
|
||
deviceId?: string;
|
||
deviceName?: string;
|
||
threadCount: number;
|
||
threads: ConversationItem[];
|
||
}
|
||
|
||
export interface ProjectMessagesRealtimePayload {
|
||
ok: true;
|
||
project: Project;
|
||
devices: Device[];
|
||
}
|
||
|
||
export function getConversationHomeItems(state: BossState): ConversationItem[] {
|
||
const flatItems = getConversationItems(state);
|
||
const projectMap = new Map(state.projects.map((project) => [project.id, project]));
|
||
const grouped = new Map<string, ConversationItem[]>();
|
||
const passthrough: ConversationItem[] = [];
|
||
|
||
for (const item of flatItems) {
|
||
const project = projectMap.get(item.projectId);
|
||
if (!project || item.conversationType !== "single_device") {
|
||
passthrough.push(item);
|
||
continue;
|
||
}
|
||
const folderKey = buildFolderKey(project);
|
||
if (!folderKey) {
|
||
passthrough.push(item);
|
||
continue;
|
||
}
|
||
const bucket = grouped.get(folderKey) ?? [];
|
||
bucket.push(item);
|
||
grouped.set(folderKey, bucket);
|
||
}
|
||
|
||
for (const [folderKey, items] of grouped) {
|
||
if (items.length <= 1) {
|
||
passthrough.push(items[0]);
|
||
continue;
|
||
}
|
||
const latestItem = [...items].sort((a, b) => b.latestReplyAt.localeCompare(a.latestReplyAt))[0];
|
||
const project = projectMap.get(latestItem.projectId);
|
||
const device = project?.deviceIds[0]
|
||
? state.devices.find((entry) => entry.id === project.deviceIds[0])
|
||
: undefined;
|
||
const topContextItem = [...items]
|
||
.filter((item) => item.contextBudgetIndicator.visible)
|
||
.sort((a, b) => {
|
||
if (a.mustFinishBeforeCompaction !== b.mustFinishBeforeCompaction) {
|
||
return a.mustFinishBeforeCompaction ? -1 : 1;
|
||
}
|
||
const aLevel = a.contextBudgetIndicator.level ?? "safe";
|
||
const bLevel = b.contextBudgetIndicator.level ?? "safe";
|
||
if (levelPriority[aLevel] !== levelPriority[bLevel]) {
|
||
return levelPriority[aLevel] - levelPriority[bLevel];
|
||
}
|
||
return b.latestReplyAt.localeCompare(a.latestReplyAt);
|
||
})[0];
|
||
const recentThreadLabel = trimLocalWorkspacePrefix(latestItem.threadTitle);
|
||
const searchAliases = buildFolderSearchAliases(items);
|
||
const latestPreview = compactImportedThreadPreview(latestItem.preview);
|
||
const latestMessagePreview = compactImportedThreadPreview(
|
||
latestItem.lastMessagePreview || latestItem.preview,
|
||
);
|
||
const historyCleared = conversationHistoryWasCleared(state);
|
||
passthrough.push({
|
||
conversationId: `folder-${folderKey}`,
|
||
conversationType: "folder_archive",
|
||
projectId: folderKey,
|
||
projectTitle:
|
||
project?.threadMeta.folderName ??
|
||
(latestItem.folderLabel || latestItem.projectTitle),
|
||
threadTitle:
|
||
project?.threadMeta.folderName ??
|
||
(latestItem.folderLabel || latestItem.threadTitle),
|
||
folderLabel: recentThreadLabel ? `${items.length} 个线程 · 最近：${recentThreadLabel}` : `${items.length} 个线程`,
|
||
folderKey,
|
||
threadCount: items.length,
|
||
topPinnedLabel: items.some((entry) => entry.topPinnedLabel) ? "置顶" : undefined,
|
||
manualPinned: items.some((entry) => entry.manualPinned),
|
||
...(searchAliases
|
||
? {
|
||
searchAliases: searchAliases.aliases,
|
||
searchTargetProjectIds: searchAliases.targetProjectIds,
|
||
}
|
||
: {}),
|
||
preview:
|
||
latestPreview ||
|
||
(historyCleared ? "" : `包含 ${items.length} 个线程，最近活跃：《${recentThreadLabel || latestItem.threadTitle}》`),
|
||
lastMessagePreview:
|
||
latestMessagePreview ||
|
||
latestPreview ||
|
||
(historyCleared ? "" : `包含 ${items.length} 个线程，最近活跃：《${recentThreadLabel || latestItem.threadTitle}》`),
|
||
activityIconCount: Math.max(0, Math.min(4, items.reduce((sum, entry) => sum + entry.activityIconCount, 0))),
|
||
latestReplyAt: latestItem.latestReplyAt,
|
||
latestReplyLabel: latestItem.latestReplyLabel,
|
||
unreadCount: items.reduce((sum, entry) => sum + entry.unreadCount, 0),
|
||
riskLevel: items.some((entry) => entry.riskLevel === "high")
|
||
? "high"
|
||
: items.some((entry) => entry.riskLevel === "medium")
|
||
? "medium"
|
||
: "low",
|
||
activeDeviceCount: 1,
|
||
deviceNamesPreview: device ? [device.name] : latestItem.deviceNamesPreview,
|
||
avatar: {
|
||
primary: device?.avatar ?? latestItem.avatar.primary,
|
||
},
|
||
contextBudgetIndicator: {
|
||
visible: Boolean(topContextItem),
|
||
style: "ring_percent",
|
||
percent: topContextItem?.contextBudgetIndicator.percent,
|
||
level: topContextItem?.contextBudgetIndicator.level,
|
||
},
|
||
contextBudgetSourceNodeId: topContextItem?.contextBudgetSourceNodeId,
|
||
contextBudgetUpdatedAt: topContextItem?.contextBudgetUpdatedAt,
|
||
mustFinishBeforeCompaction: Boolean(topContextItem?.mustFinishBeforeCompaction),
|
||
});
|
||
}
|
||
|
||
return sortConversationItems(passthrough);
|
||
}
|
||
|
||
export function getConversationHomeItemsForSession(
|
||
state: BossState,
|
||
session: Pick<AuthSession, "account" | "role" | "displayName">,
|
||
): ConversationItem[] {
|
||
return getConversationHomeItems(stateForSession(state, session));
|
||
}
|
||
|
||
export function getConversationWebItems(state: BossState): ConversationItem[] {
|
||
return getConversationHomeItems(state).map((item) => ({
|
||
...item,
|
||
topPinnedLabel: undefined,
|
||
manualPinned: false,
|
||
}));
|
||
}
|
||
|
||
export function getConversationHomeItemForProject(state: BossState, projectId: string): ConversationItem | null {
|
||
const normalizedProjectId = projectId.trim();
|
||
if (!normalizedProjectId) {
|
||
return null;
|
||
}
|
||
return (
|
||
getConversationHomeItems(state).find((item) => {
|
||
if (item.projectId === normalizedProjectId) {
|
||
return true;
|
||
}
|
||
return Array.isArray(item.searchTargetProjectIds)
|
||
? item.searchTargetProjectIds.includes(normalizedProjectId)
|
||
: false;
|
||
}) ?? null
|
||
);
|
||
}
|
||
|
||
export function getConversationThreadItemForProject(state: BossState, projectId: string): ConversationItem | null {
|
||
const normalizedProjectId = projectId.trim();
|
||
if (!normalizedProjectId) {
|
||
return null;
|
||
}
|
||
return getConversationItems(state).find((item) => item.projectId === normalizedProjectId) ?? null;
|
||
}
|
||
|
||
export function getConversationFolderView(
|
||
state: BossState,
|
||
folderKey: string,
|
||
): ConversationFolderView | null {
|
||
const flatItems = getConversationItems(state).filter(
|
||
(item) => item.conversationType === "single_device" && item.folderKey === folderKey,
|
||
);
|
||
if (flatItems.length === 0) {
|
||
return null;
|
||
}
|
||
const project = state.projects.find((entry) => buildFolderKey(entry) === folderKey);
|
||
const deviceId = project?.deviceIds[0];
|
||
const device = deviceId ? state.devices.find((entry) => entry.id === deviceId) : undefined;
|
||
return {
|
||
folderKey,
|
||
folderLabel: project?.threadMeta.folderName ?? flatItems[0].folderLabel,
|
||
deviceId,
|
||
deviceName: device?.name,
|
||
threadCount: flatItems.length,
|
||
threads: sortConversationItems(flatItems),
|
||
};
|
||
}
|
||
|
||
export function getConversationFolderViewForSession(
|
||
state: BossState,
|
||
session: Pick<AuthSession, "account" | "role" | "displayName">,
|
||
folderKey: string,
|
||
): ConversationFolderView | null {
|
||
return getConversationFolderView(stateForSession(state, session), folderKey);
|
||
}
|
||
|
||
export function buildProjectMessagesRealtimePayload(
|
||
state: BossState,
|
||
projectId: string,
|
||
): ProjectMessagesRealtimePayload | null {
|
||
const normalizedProjectId = projectId.trim();
|
||
if (!normalizedProjectId) {
|
||
return null;
|
||
}
|
||
const project = state.projects.find((item) => item.id === normalizedProjectId);
|
||
if (!project) {
|
||
return null;
|
||
}
|
||
return {
|
||
ok: true,
|
||
project: cloneProjectWithDisplayTitles(project),
|
||
devices: state.devices.filter((device) => project.deviceIds.includes(device.id)),
|
||
};
|
||
}
|
||
|
||
export function buildProjectMessagesRealtimePayloadForSession(
|
||
state: BossState,
|
||
session: Pick<AuthSession, "account" | "role" | "displayName">,
|
||
projectId: string,
|
||
): ProjectMessagesRealtimePayload | null {
|
||
if (!canAccessProject(state, session, projectId, "project.view")) {
|
||
return null;
|
||
}
|
||
const project = state.projects.find((item) => item.id === projectId);
|
||
if (!project) {
|
||
return null;
|
||
}
|
||
const scopedProject =
|
||
project.id === "master-agent" && session.role !== "highest_admin"
|
||
? projectWithAccountScopedMasterMessages(cloneProjectWithDisplayTitles(project), session.account)
|
||
: cloneProjectWithDisplayTitles(project);
|
||
return {
|
||
ok: true,
|
||
project: scopedProject,
|
||
devices: filterProjectDevicesForSession(state, session, project),
|
||
};
|
||
}
|
||
|
||
function resolveProjectAgentControls(
|
||
state: BossState,
|
||
projectId: string,
|
||
account?: string,
|
||
) {
|
||
const normalizedAccount = account?.trim();
|
||
const scoped = normalizedAccount
|
||
? (
|
||
state.userProjectAgentControls.find(
|
||
(item) => item.projectId === projectId && item.account === normalizedAccount,
|
||
) ?? null
|
||
)
|
||
: null;
|
||
const projectControls = scoped?.controls ?? state.projects.find((item) => item.id === projectId)?.agentControls ?? null;
|
||
if (projectId === "master-agent") {
|
||
return projectControls;
|
||
}
|
||
const globalControls = normalizedAccount
|
||
? (
|
||
state.userProjectAgentControls.find(
|
||
(item) => item.projectId === "master-agent" && item.account === normalizedAccount,
|
||
)?.controls ?? state.projects.find((item) => item.id === "master-agent")?.agentControls ?? null
|
||
)
|
||
: state.projects.find((item) => item.id === "master-agent")?.agentControls ?? null;
|
||
const explicitTakeover = projectControls?.takeoverEnabled;
|
||
const inheritedGlobalTakeover = globalControls?.globalTakeoverEnabled;
|
||
const effectiveTakeoverEnabled =
|
||
explicitTakeover !== undefined ? explicitTakeover : Boolean(inheritedGlobalTakeover);
|
||
const takeoverInheritedFromGlobal =
|
||
explicitTakeover === undefined && inheritedGlobalTakeover !== undefined;
|
||
if (!projectControls && !takeoverInheritedFromGlobal && !effectiveTakeoverEnabled) {
|
||
return null;
|
||
}
|
||
return {
|
||
...(projectControls ?? { updatedAt: globalControls?.updatedAt ?? new Date().toISOString() }),
|
||
updatedAt: projectControls?.updatedAt ?? globalControls?.updatedAt ?? new Date().toISOString(),
|
||
effectiveTakeoverEnabled,
|
||
takeoverInheritedFromGlobal,
|
||
};
|
||
}
|
||
|
||
export function getProjectDetailView(state: BossState, projectId: string, account?: string): ProjectDetailView | null {
|
||
const project = state.projects.find((item) => item.id === projectId);
|
||
if (!project) return null;
|
||
const displayProject = cloneProjectWithDisplayTitles(project);
|
||
|
||
const activeThreadContexts = threadViewsForProject(state, projectId);
|
||
const threadsRequiringHandoff = activeThreadContexts.filter(
|
||
(item) =>
|
||
item.snapshot.mustFinishBeforeCompaction ||
|
||
item.snapshot.contextBudgetLevel === "urgent" ||
|
||
item.snapshot.contextBudgetLevel === "critical",
|
||
);
|
||
|
||
const openFaults = state.opsFaults.filter(
|
||
(fault) => fault.projectId === projectId && fault.status !== "resolved",
|
||
);
|
||
const relatedAuditResults = state.auditResults.filter((result) =>
|
||
state.auditRequests.some(
|
||
(request) => request.auditRequestId === result.auditRequestId && request.projectId === projectId,
|
||
),
|
||
);
|
||
|
||
const topRisk = threadsRequiringHandoff[0]?.snapshot ?? activeThreadContexts[0]?.snapshot;
|
||
const masterContextStrategySummary = topRisk
|
||
? `${topRisk.title} 需要优先处理，当前 ${topRisk.contextBudgetLevel} ${topRisk.contextBudgetRemainingPct}%${topRisk.mustFinishBeforeCompaction ? "，必须先固化 patch / 测试 / 证据" : ""}。`
|
||
: "当前没有高风险线程，主 Agent 可以继续按正常优先级调度。";
|
||
const projectDeviceIds = new Set(project.deviceIds);
|
||
const recentAppLogs = [...state.appLogs]
|
||
.filter((log) =>
|
||
projectId === "master-agent"
|
||
? true
|
||
: log.projectId === projectId || projectDeviceIds.has(log.deviceId),
|
||
)
|
||
.sort((a, b) => b.createdAt.localeCompare(a.createdAt))
|
||
.slice(0, 6);
|
||
|
||
return {
|
||
project: displayProject,
|
||
agentControls: resolveProjectAgentControls(state, projectId, account),
|
||
devices: state.devices.filter((device) => project.deviceIds.includes(device.id)),
|
||
masterIdentity: projectId === "master-agent" ? getProjectMasterIdentity(state) : undefined,
|
||
activeThreadContexts,
|
||
nextCompactionRiskThreadId: topRisk?.threadId,
|
||
threadsRequiringHandoff,
|
||
masterContextStrategySummary,
|
||
recentAppLogs,
|
||
openFaults,
|
||
relatedAuditResults,
|
||
};
|
||
}
|
||
|
||
export function getProjectDetailViewForSession(
|
||
state: BossState,
|
||
projectId: string,
|
||
session: Pick<AuthSession, "account" | "role" | "displayName">,
|
||
): ProjectDetailView | null {
|
||
if (!canAccessProject(state, session, projectId, "project.view")) {
|
||
return null;
|
||
}
|
||
const detail = getProjectDetailView(state, projectId, session.account);
|
||
if (!detail) {
|
||
return null;
|
||
}
|
||
const visibleProjectIds = new Set(filterProjectsForSession(state, session).map((project) => project.id));
|
||
const visibleDeviceIds = new Set(filterDevicesForSession(state, session).map((device) => device.id));
|
||
return {
|
||
...detail,
|
||
devices: filterProjectDevicesForSession(state, session, detail.project),
|
||
activeThreadContexts: detail.activeThreadContexts.filter((item) =>
|
||
visibleProjectIds.has(item.snapshot.projectId) && visibleDeviceIds.has(item.snapshot.nodeId),
|
||
),
|
||
threadsRequiringHandoff: detail.threadsRequiringHandoff.filter((item) =>
|
||
visibleProjectIds.has(item.snapshot.projectId) && visibleDeviceIds.has(item.snapshot.nodeId),
|
||
),
|
||
recentAppLogs: detail.recentAppLogs.filter((log) =>
|
||
visibleDeviceIds.has(log.deviceId) ||
|
||
Boolean(log.projectId && visibleProjectIds.has(log.projectId)),
|
||
),
|
||
};
|
||
}
|
||
|
||
export function getThreadContextDetailView(
|
||
state: BossState,
|
||
threadId: string,
|
||
): ThreadContextDetailView | null {
|
||
const snapshot = state.threadContextSnapshots.find((item) => item.threadId === threadId);
|
||
if (!snapshot) return null;
|
||
const handoffPackage = state.threadHandoffPackages.find(
|
||
(item) => item.fromThreadId === threadId && item.packageStatus !== "expired",
|
||
);
|
||
const alerts = state.threadContextAlerts.filter((item) => item.threadId === threadId);
|
||
const masterActions = Array.from(
|
||
new Set(alerts.flatMap((alert) => alert.masterActions)),
|
||
);
|
||
|
||
return {
|
||
snapshot,
|
||
handoffPackage,
|
||
alerts,
|
||
currentChecklist: snapshot.checklist,
|
||
masterActions,
|
||
};
|
||
}
|
||
|
||
export function getDeviceWorkspaceView(
|
||
state: BossState,
|
||
deviceId?: string,
|
||
): DeviceWorkspaceView {
|
||
if (!deviceId) {
|
||
return {
|
||
relatedThreads: [],
|
||
};
|
||
}
|
||
const selectedDevice = state.devices.find((item) => item.id === deviceId);
|
||
return {
|
||
selectedDevice: selectedDevice ? { ...selectedDevice } : undefined,
|
||
relatedThreads: state.threadContextSnapshots.filter((item) => item.nodeId === deviceId),
|
||
activeEnrollment: state.deviceEnrollments.find((item) => item.deviceId === deviceId),
|
||
importDraft: state.deviceImportDrafts.find((item) => item.deviceId === deviceId),
|
||
importResolution: state.deviceImportResolutions.find((item) => item.deviceId === deviceId),
|
||
projectExecutionPolicies: state.projectExecutionPolicies.filter((item) => item.deviceId === deviceId),
|
||
};
|
||
}
|
||
|
||
export function getDeviceWorkspaceViewForSession(
|
||
state: BossState,
|
||
session: Pick<AuthSession, "account" | "role" | "displayName">,
|
||
deviceId?: string,
|
||
): DeviceWorkspaceView {
|
||
if (!deviceId || !canAccessDevice(state, session, deviceId, "device.view")) {
|
||
return { relatedThreads: [] };
|
||
}
|
||
return getDeviceWorkspaceView(stateForSession(state, session), deviceId);
|
||
}
|
||
|
||
export function getOpsSummaryView(state: BossState): OpsSummaryView {
|
||
const tickets = state.opsRepairTickets.map((ticket) => ({
|
||
...ticket,
|
||
verification: state.opsRepairVerifications.find((item) => item.ticketId === ticket.ticketId),
|
||
}));
|
||
const mode =
|
||
state.opsFaults.some((fault) => fault.status !== "resolved") ||
|
||
state.threadContextSnapshots.some(
|
||
(snapshot) =>
|
||
snapshot.contextBudgetLevel === "urgent" || snapshot.contextBudgetLevel === "critical",
|
||
)
|
||
? "active"
|
||
: "idle";
|
||
|
||
return {
|
||
mode,
|
||
faults: [...state.opsFaults].sort((a, b) => b.lastSeenAt.localeCompare(a.lastSeenAt)),
|
||
tickets: tickets.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt)),
|
||
};
|
||
}
|
||
|
||
export function getAuditSummaryView(state: BossState): AuditSummaryView {
|
||
const completedIds = new Set(state.auditResults.map((result) => result.auditRequestId));
|
||
return {
|
||
pendingRequests: state.auditRequests.filter(
|
||
(request) => !completedIds.has(request.auditRequestId),
|
||
),
|
||
latestResults: [...state.auditResults].sort((a, b) =>
|
||
b.completedAt.localeCompare(a.completedAt),
|
||
),
|
||
capabilities: state.capabilities,
|
||
};
|
||
}
|
||
|
||
export function getSkillInventoryView(state: BossState): SkillInventoryView {
|
||
return getSkillInventoryViewForAccount(
|
||
state,
|
||
state.user.account,
|
||
state.user.boundDeviceId,
|
||
);
|
||
}
|
||
|
||
export function getSkillInventoryViewForAccount(
|
||
state: BossState,
|
||
account: string,
|
||
boundDeviceId?: string,
|
||
): SkillInventoryView {
|
||
const devices = state.devices
|
||
.filter(
|
||
(device) =>
|
||
device.account === account || device.id === boundDeviceId,
|
||
)
|
||
.sort((a, b) => {
|
||
if (a.id === boundDeviceId) return -1;
|
||
if (b.id === boundDeviceId) return 1;
|
||
return b.lastSeenAt.localeCompare(a.lastSeenAt);
|
||
});
|
||
|
||
return {
|
||
boundDeviceId,
|
||
groups: devices
|
||
.map((device) => ({
|
||
device,
|
||
skills: state.deviceSkills
|
||
.filter((skill) => skill.deviceId === device.id)
|
||
.sort((a, b) => a.name.localeCompare(b.name, "zh-CN")),
|
||
}))
|
||
.filter((group) => group.skills.length > 0),
|
||
};
|
||
}
|
||
|
||
export function getSkillInventoryViewForSession(
|
||
state: BossState,
|
||
session: Pick<AuthSession, "account" | "role" | "displayName">,
|
||
boundDeviceId?: string,
|
||
): SkillInventoryView {
|
||
const devices = filterDevicesForSession(state, session)
|
||
.filter((device) => !boundDeviceId || device.id === boundDeviceId || session.role === "highest_admin")
|
||
.sort((a, b) => {
|
||
if (a.id === boundDeviceId) return -1;
|
||
if (b.id === boundDeviceId) return 1;
|
||
return b.lastSeenAt.localeCompare(a.lastSeenAt);
|
||
});
|
||
|
||
return {
|
||
boundDeviceId,
|
||
groups: devices
|
||
.map((device) => ({
|
||
device,
|
||
skills: state.deviceSkills
|
||
.filter((skill) => skill.deviceId === device.id)
|
||
.filter((skill) =>
|
||
session.role === "highest_admin" ||
|
||
canViewSkill(state, session, skill.skillId, { deviceId: device.id }),
|
||
)
|
||
.sort((a, b) => a.name.localeCompare(b.name, "zh-CN")),
|
||
}))
|
||
.filter((group) => group.skills.length > 0),
|
||
};
|
||
}
|