6281 lines
257 KiB
TypeScript
6281 lines
257 KiB
TypeScript
import type {
|
||
ApprovalEntry,
|
||
ApprovalSubscriptionPreferences,
|
||
ApprovalTimelineResponse,
|
||
ArtifactEntry,
|
||
CanonicalEvent,
|
||
CronJob,
|
||
CronRun,
|
||
CostSummary,
|
||
DashboardResponse,
|
||
DebugPlan,
|
||
DebugRun,
|
||
DebugStoreResponse,
|
||
DebugTask,
|
||
DiagResult,
|
||
DigitalEmployeeDailyReport,
|
||
DigitalEmployeeDecision,
|
||
DigitalEmployeeDiagnosticSummary,
|
||
DigitalEmployeeDuty,
|
||
DigitalEmployeeManagedService,
|
||
DigitalEmployeePlanAgentState,
|
||
DigitalEmployeeRouteSummary,
|
||
DigitalEmployeeRunDetail,
|
||
DigitalEmployeeTaskAgentState,
|
||
DigitalEmployeeTaskExecutionSummary,
|
||
DigitalEmployeeWorkEvent,
|
||
DigitalEmployeeWorkdayActionRequest,
|
||
DigitalEmployeeWorkdayProjection,
|
||
FlowResponse,
|
||
GovernanceCommandRequest,
|
||
GovernanceCommandResponse,
|
||
IngressRouteRequest,
|
||
IngressRouteResponse,
|
||
MemoryEntry,
|
||
NotificationPreferences,
|
||
PlanDispatchResponse,
|
||
ReadyStepDispatchResult,
|
||
PlanStepDispatchPolicy,
|
||
PlanStepSummary,
|
||
RouteDecisionRecord,
|
||
RouteDecisionTimelineResponse,
|
||
SkillSpec,
|
||
UserNotification,
|
||
} from '@/types/api';
|
||
|
||
declare global {
|
||
interface Window {
|
||
__QIMINGCLAW_EMBEDDED_DIGITAL__?: boolean;
|
||
QimingClawBridge?: {
|
||
digital?: {
|
||
getSnapshot?: () => Promise<QimingclawSnapshot>;
|
||
getRuntimeRecords?: () => Promise<QimingclawRuntimeRecords>;
|
||
getUiState?: () => Promise<AdapterState>;
|
||
getSkillCapabilities?: () => Promise<QimingclawSkillCapabilities>;
|
||
setSkillEnabled?: (skillId: string, enabled: boolean) => Promise<{ ok?: boolean; skill_id?: string; enabled?: boolean; error?: string }>;
|
||
getPlanTemplates?: () => Promise<QimingclawPlanTemplateList>;
|
||
listMemories?: (options?: { query?: string; category?: string; limit?: number }) => Promise<QimingclawMemoryRecord[]>;
|
||
addMemory?: (input: QimingclawMemoryUpsertInput) => Promise<QimingclawMemoryRecord | null>;
|
||
deleteMemory?: (keyOrId: string) => Promise<QimingclawMemoryRecord | null>;
|
||
saveUiState?: (update: { state: AdapterState; action?: string; date?: string; metadata?: Record<string, unknown> }) => Promise<AdapterState>;
|
||
getSyncStatus?: () => Promise<QimingclawSyncStatus>;
|
||
flushSync?: () => Promise<QimingclawSyncStatus>;
|
||
getCronSettings?: () => Promise<QimingclawCronSettings>;
|
||
saveCronSettings?: (patch: Partial<QimingclawCronSettings>) => Promise<QimingclawCronSettings>;
|
||
runSchedulerCheck?: () => Promise<{ activated: number; due?: number; skipped?: number }>;
|
||
runScheduleNow?: (scheduleId: string) => Promise<{ ok?: boolean; scheduleRunId?: string; error?: string }>;
|
||
dispatchPlanReadySteps?: (planId: string) => Promise<ReadyStepDispatchResult>;
|
||
getScheduleRuns?: (scheduleId: string, limit?: number) => Promise<QimingclawScheduleRunRecord[]>;
|
||
listRouteDecisions?: (options?: { limit?: number }) => Promise<RouteDecisionRecord[]>;
|
||
recordRouteDecision?: (input: QimingclawRouteDecisionInput) => Promise<RouteDecisionRecord>;
|
||
recordGovernanceCommand?: (command: QimingclawGovernanceCommandRecord) => Promise<unknown>;
|
||
recordDailyReport?: (input: QimingclawDailyReportRecordInput) => Promise<QimingclawDailyReportRecordResult | null>;
|
||
accessArtifact?: (artifactId: string, action: 'preview' | 'download' | 'open_location', options?: { actor?: string | null; source?: string | null }) => Promise<QimingclawArtifactAccessResponse>;
|
||
recordArtifactLifecycle?: (input: QimingclawArtifactLifecycleInput) => Promise<QimingclawArtifactLifecycleResult | null>;
|
||
recordApprovalAction?: (input: QimingclawApprovalActionInput) => Promise<QimingclawApprovalActionResult | null>;
|
||
restartManagedService?: (serviceId: string, options?: { reason?: string | null; actor?: string | null }) => Promise<QimingclawManagedServiceActionResponse>;
|
||
respondPermission?: (sessionId: string, permissionId: string, response: 'once' | 'always' | 'reject') => Promise<{ success?: boolean; error?: string }>;
|
||
};
|
||
};
|
||
}
|
||
}
|
||
|
||
const STATE_KEY = 'qimingclaw:digital-employee-adapter-state';
|
||
const DEFAULT_REPORT_TIME = '18:00';
|
||
|
||
interface AdapterState {
|
||
selectedDutyIdsByDate: Record<string, string[]>;
|
||
confirmedDates: Record<string, string>;
|
||
reportScheduleTime: string;
|
||
reportGeneratedAtByDate: Record<string, string>;
|
||
decisionResultsByDate: Record<string, Record<string, string>>;
|
||
notificationStateById?: Record<string, NotificationState>;
|
||
notificationPreferences?: NotificationPreferences;
|
||
approvalSubscriptionPreferences?: ApprovalSubscriptionPreferences;
|
||
planStepDispatchPolicy?: PlanStepDispatchPolicy;
|
||
consoleRole?: string;
|
||
rolePreferences?: Record<string, unknown>;
|
||
profile: {
|
||
name: string;
|
||
company: string;
|
||
position: string;
|
||
currentStatus: string;
|
||
};
|
||
}
|
||
|
||
interface NotificationState {
|
||
status?: UserNotification['status'];
|
||
read_at?: string | null;
|
||
dismissed_at?: string | null;
|
||
reply?: string | null;
|
||
replied_at?: string | null;
|
||
}
|
||
|
||
const NOTIFICATION_LEVELS: UserNotification['level'][] = ['info', 'warn', 'error', 'action'];
|
||
const NOTIFICATION_KINDS: UserNotification['kind'][] = [
|
||
'user_message',
|
||
'need_input',
|
||
'need_approval',
|
||
'task_progress',
|
||
'task_failed',
|
||
'task_finished',
|
||
'confirmation_pending',
|
||
'confirmation_resolved',
|
||
];
|
||
const APPROVAL_SUBSCRIPTION_ACTIONS: ApprovalSubscriptionPreferences['subscribed_actions'] = ['comment', 'delegate', 'mark_timeout', 'mark_risk', 'clear_risk', 'decision'];
|
||
const APPROVAL_SUBSCRIPTION_RISK_LEVELS: ApprovalSubscriptionPreferences['subscribed_risk_levels'] = ['normal', 'medium', 'high', 'critical'];
|
||
|
||
interface QimingclawServiceStatus {
|
||
running?: boolean;
|
||
error?: string;
|
||
engineType?: string;
|
||
port?: number;
|
||
serverCount?: number;
|
||
serverNames?: string[];
|
||
}
|
||
|
||
interface QimingclawSyncStatus {
|
||
running: boolean;
|
||
syncing: boolean;
|
||
enabled: boolean;
|
||
endpoint: string | null;
|
||
missingCredentials?: string[];
|
||
pending: number;
|
||
failed: number;
|
||
lastSyncAt: string | null;
|
||
lastSyncError: string | null;
|
||
failureSummary?: QimingclawSyncFailureSummary;
|
||
recentFailures?: QimingclawSyncFailure[];
|
||
}
|
||
|
||
interface QimingclawSyncFailureSummary {
|
||
total: number;
|
||
dueForRetry: number;
|
||
backoff: number;
|
||
byEntityType: Array<{ entityType: string; count: number }>;
|
||
}
|
||
|
||
interface QimingclawSyncAttempt {
|
||
attemptNo: number;
|
||
status: string;
|
||
error: string | null;
|
||
endpoint?: string | null;
|
||
startedAt: string;
|
||
finishedAt: string;
|
||
}
|
||
|
||
interface QimingclawSyncFailure {
|
||
id: string;
|
||
entityType: string;
|
||
entityId: string;
|
||
operation: string;
|
||
attempts: number;
|
||
lastAttemptAt: string | null;
|
||
nextRetryAt?: string | null;
|
||
dueForRetry?: boolean;
|
||
managementRecordUrl?: string | null;
|
||
attemptHistory?: QimingclawSyncAttempt[];
|
||
error: string | null;
|
||
createdAt: string;
|
||
updatedAt: string;
|
||
}
|
||
|
||
interface QimingclawSnapshot {
|
||
generatedAt: string;
|
||
services: Record<string, QimingclawServiceStatus | null>;
|
||
managedServices?: QimingclawManagedService[] | null;
|
||
sessions: {
|
||
total: number;
|
||
active: number;
|
||
items: Array<{ id: string; title?: string; status?: string; engineType?: string; projectId?: string }>;
|
||
};
|
||
sync?: QimingclawSyncStatus | null;
|
||
runtime?: QimingclawRuntimeRecords | null;
|
||
uiState?: AdapterState | null;
|
||
planTemplates?: QimingclawPlanTemplateRecord[] | null;
|
||
}
|
||
|
||
interface QimingclawManagedService {
|
||
serviceId: string;
|
||
name: string;
|
||
kind: string;
|
||
status: string;
|
||
statusLabel: string;
|
||
running: boolean;
|
||
error?: string | null;
|
||
requiresHumanAction: boolean;
|
||
dependentTasks: string[];
|
||
restartCount: number;
|
||
lastSeenAt: string;
|
||
instance?: Record<string, unknown>;
|
||
lease?: Record<string, unknown>;
|
||
}
|
||
|
||
interface QimingclawPlanTemplateList {
|
||
generatedAt: string;
|
||
templateDir: string;
|
||
templates: QimingclawPlanTemplateRecord[];
|
||
}
|
||
|
||
interface QimingclawPlanTemplateRecord extends DebugPlan {
|
||
source: 'qimingclaw-plan-template';
|
||
template_path: string;
|
||
updated_at: string;
|
||
}
|
||
|
||
interface QimingclawGovernanceCommandRecord {
|
||
commandKind: string;
|
||
commandId: string;
|
||
correlationId?: string;
|
||
planId?: string | null;
|
||
taskId?: string | null;
|
||
runId?: string | null;
|
||
stepId?: string | null;
|
||
scheduleId?: string | null;
|
||
accepted?: boolean;
|
||
message?: string;
|
||
error?: string | null;
|
||
payload?: Record<string, unknown> | null;
|
||
result?: Record<string, unknown> | null;
|
||
}
|
||
|
||
interface QimingclawDailyReportRecordInput {
|
||
reportId?: string | null;
|
||
date: string;
|
||
title: string;
|
||
summary: string;
|
||
totals: Record<string, unknown>;
|
||
detailLines: string[];
|
||
artifactSources?: unknown[];
|
||
filename: string;
|
||
textContent: string;
|
||
generatedAt?: string | null;
|
||
reportScheduleTime?: string | null;
|
||
source?: string | null;
|
||
model?: string | null;
|
||
}
|
||
|
||
interface QimingclawDailyReportRecordResult {
|
||
reportId: string;
|
||
planId: string;
|
||
taskId: string;
|
||
runId: string;
|
||
artifactId: string;
|
||
eventId: string;
|
||
}
|
||
|
||
interface QimingclawArtifactAccessResponse {
|
||
ok: boolean;
|
||
artifact_id: string;
|
||
action: 'preview' | 'download' | 'open_location';
|
||
status: 'allowed' | 'rejected';
|
||
error?: string;
|
||
reason_codes?: string[];
|
||
preview?: Record<string, unknown>;
|
||
event_id?: string | null;
|
||
}
|
||
|
||
interface QimingclawArtifactLifecycleInput {
|
||
artifactId?: string | null;
|
||
action: string;
|
||
reason?: string | null;
|
||
retentionUntil?: string | null;
|
||
versionSummary?: Record<string, unknown> | null;
|
||
retentionSummary?: Record<string, unknown> | null;
|
||
deliverySummary?: Record<string, unknown> | null;
|
||
actor?: string | null;
|
||
source?: string | null;
|
||
planId?: string | null;
|
||
taskId?: string | null;
|
||
runId?: string | null;
|
||
}
|
||
|
||
interface QimingclawArtifactLifecycleResult {
|
||
eventId: string;
|
||
kind: string;
|
||
payload: Record<string, unknown>;
|
||
}
|
||
|
||
interface QimingclawApprovalActionInput {
|
||
approvalId?: string | null;
|
||
action: string;
|
||
comment?: string | null;
|
||
delegateTo?: string | null;
|
||
delegateLabel?: string | null;
|
||
dueAt?: string | null;
|
||
riskLevel?: string | null;
|
||
reason?: string | null;
|
||
actor?: string | null;
|
||
source?: string | null;
|
||
planId?: string | null;
|
||
taskId?: string | null;
|
||
runId?: string | null;
|
||
}
|
||
|
||
interface QimingclawApprovalActionResult {
|
||
eventId: string;
|
||
kind: string;
|
||
payload: Record<string, unknown>;
|
||
}
|
||
|
||
interface QimingclawManagedServiceActionResponse {
|
||
ok: boolean;
|
||
service_id: string;
|
||
action: 'restart';
|
||
status: 'success' | 'failed' | 'rejected';
|
||
message?: string;
|
||
error?: string;
|
||
managed_service?: DigitalEmployeeManagedService | null;
|
||
event_id?: string | null;
|
||
}
|
||
|
||
interface QimingclawRouteDecisionInput {
|
||
id?: string | null;
|
||
idempotencyKey?: string | null;
|
||
correlationId?: string | null;
|
||
routeKind: string;
|
||
intentKind: string;
|
||
reasonCodes?: string[];
|
||
candidateSkills?: string[];
|
||
contextRefs?: Record<string, unknown>;
|
||
createdCommandId?: string | null;
|
||
createsPlan?: boolean;
|
||
createsTaskRun?: boolean;
|
||
approvalMode?: string | null;
|
||
policyResult?: string | null;
|
||
entrypoint?: string | null;
|
||
actor?: string | null;
|
||
message?: string | null;
|
||
envelope?: Record<string, unknown> | null;
|
||
recordedAt?: string | null;
|
||
}
|
||
|
||
interface QimingclawRuntimeRecords {
|
||
generatedAt: string;
|
||
plans: QimingclawPlanRecord[];
|
||
planSteps?: QimingclawPlanStepRecord[];
|
||
schedules?: QimingclawScheduleRecord[];
|
||
scheduleRuns?: QimingclawScheduleRunRecord[];
|
||
tasks: QimingclawTaskRecord[];
|
||
runs: QimingclawRunRecord[];
|
||
events: QimingclawEventRecord[];
|
||
artifacts?: QimingclawArtifactRecord[];
|
||
approvals?: QimingclawApprovalRecord[];
|
||
memories?: QimingclawMemoryRecord[];
|
||
}
|
||
|
||
interface QimingclawMemoryRecord {
|
||
id: string;
|
||
remoteId?: string | null;
|
||
key: string;
|
||
content: string;
|
||
category: string;
|
||
source: string;
|
||
sourcePath?: string | null;
|
||
sessionId?: string | null;
|
||
score?: number | null;
|
||
status: string;
|
||
payload: unknown;
|
||
syncStatus: string;
|
||
lastSyncedAt?: string | null;
|
||
syncError?: string | null;
|
||
createdAt: string;
|
||
updatedAt: string;
|
||
deletedAt?: string | null;
|
||
}
|
||
|
||
interface QimingclawMemoryUpsertInput {
|
||
id?: string;
|
||
key?: string;
|
||
content: string;
|
||
category?: string;
|
||
source?: string;
|
||
sourcePath?: string | null;
|
||
sessionId?: string | null;
|
||
score?: number | null;
|
||
status?: string;
|
||
payload?: Record<string, unknown>;
|
||
}
|
||
|
||
interface QimingclawCronSettings {
|
||
enabled: boolean;
|
||
catch_up_on_startup: boolean;
|
||
max_run_history: number;
|
||
max_catch_up_runs: number;
|
||
max_concurrent_schedule_runs: number;
|
||
}
|
||
|
||
interface QimingclawScheduleRecord {
|
||
id: string;
|
||
remoteId?: string | null;
|
||
planId?: string | null;
|
||
name: string;
|
||
description?: string | null;
|
||
cronExpr: string;
|
||
timezone: string;
|
||
status: string;
|
||
enabled: boolean;
|
||
prompt?: string | null;
|
||
command?: string | null;
|
||
payload: unknown;
|
||
nextRunAt?: string | null;
|
||
lastRunAt?: string | null;
|
||
catchUpOnStartup: boolean;
|
||
maxCatchUpRuns: number;
|
||
maxRunHistory: number;
|
||
failureCount: number;
|
||
lastError?: string | null;
|
||
syncStatus: string;
|
||
createdAt: string;
|
||
updatedAt: string;
|
||
deletedAt?: string | null;
|
||
}
|
||
|
||
interface QimingclawScheduleRunRecord {
|
||
id: string;
|
||
scheduleId: string;
|
||
planId?: string | null;
|
||
runId?: string | null;
|
||
dueAt: string;
|
||
startedAt?: string | null;
|
||
finishedAt?: string | null;
|
||
status: string;
|
||
attemptNo: number;
|
||
triggerKind: string;
|
||
error?: string | null;
|
||
payload: unknown;
|
||
createdAt: string;
|
||
updatedAt: string;
|
||
}
|
||
|
||
interface QimingclawPlanRecord {
|
||
id: string;
|
||
remoteId?: string | null;
|
||
title: string;
|
||
objective?: string | null;
|
||
status: string;
|
||
source: string;
|
||
payload: unknown;
|
||
syncStatus: string;
|
||
lastSyncedAt?: string | null;
|
||
syncError?: string | null;
|
||
createdAt: string;
|
||
updatedAt: string;
|
||
}
|
||
|
||
interface QimingclawPlanStepRecord {
|
||
id: string;
|
||
remoteId?: string | null;
|
||
planId: string;
|
||
title: string;
|
||
status: string;
|
||
seq: number;
|
||
dependsOn: string[];
|
||
preferredSkillIds: string[];
|
||
payload: unknown;
|
||
syncStatus: string;
|
||
lastSyncedAt?: string | null;
|
||
syncError?: string | null;
|
||
createdAt: string;
|
||
updatedAt: string;
|
||
}
|
||
|
||
interface QimingclawTaskRecord {
|
||
id: string;
|
||
remoteId?: string | null;
|
||
planId?: string | null;
|
||
title: string;
|
||
status: string;
|
||
assignedSkillId?: string | null;
|
||
payload: unknown;
|
||
syncStatus: string;
|
||
lastSyncedAt?: string | null;
|
||
syncError?: string | null;
|
||
createdAt: string;
|
||
updatedAt: string;
|
||
}
|
||
|
||
interface QimingclawRunRecord {
|
||
id: string;
|
||
remoteId?: string | null;
|
||
planId?: string | null;
|
||
taskId?: string | null;
|
||
status: string;
|
||
startedAt?: string | null;
|
||
finishedAt?: string | null;
|
||
payload: unknown;
|
||
syncStatus: string;
|
||
lastSyncedAt?: string | null;
|
||
syncError?: string | null;
|
||
createdAt: string;
|
||
updatedAt: string;
|
||
}
|
||
|
||
interface QimingclawEventRecord {
|
||
id: string;
|
||
remoteId?: string | null;
|
||
planId?: string | null;
|
||
taskId?: string | null;
|
||
runId?: string | null;
|
||
kind: string;
|
||
message: string;
|
||
payload: unknown;
|
||
syncStatus: string;
|
||
lastSyncedAt?: string | null;
|
||
syncError?: string | null;
|
||
occurredAt: string;
|
||
createdAt: string;
|
||
}
|
||
|
||
interface QimingclawArtifactRecord {
|
||
id: string;
|
||
remoteId?: string | null;
|
||
planId?: string | null;
|
||
taskId?: string | null;
|
||
runId?: string | null;
|
||
kind: string;
|
||
name?: string | null;
|
||
uri?: string | null;
|
||
payload: unknown;
|
||
syncStatus: string;
|
||
lastSyncedAt?: string | null;
|
||
syncError?: string | null;
|
||
createdAt: string;
|
||
}
|
||
|
||
interface QimingclawApprovalRecord {
|
||
id: string;
|
||
remoteId?: string | null;
|
||
planId?: string | null;
|
||
taskId?: string | null;
|
||
runId?: string | null;
|
||
title: string;
|
||
status: string;
|
||
payload: unknown;
|
||
syncStatus: string;
|
||
lastSyncedAt?: string | null;
|
||
syncError?: string | null;
|
||
createdAt: string;
|
||
updatedAt: string;
|
||
}
|
||
|
||
interface QimingclawSkillCapabilities {
|
||
generatedAt: string;
|
||
skills: SkillSpec[];
|
||
}
|
||
|
||
const SKILLS: SkillSpec[] = [
|
||
{
|
||
skill_id: 'qimingclaw-acp-session',
|
||
name: 'ACP 会话执行',
|
||
version: '1.0.0',
|
||
enabled: true,
|
||
description: '通过 qimingclaw 的 ACP 引擎创建会话、执行任务并跟踪结果。',
|
||
category: '执行',
|
||
capability_level: 'core',
|
||
},
|
||
{
|
||
skill_id: 'qimingclaw-mcp-tools',
|
||
name: 'MCP 工具编排',
|
||
version: '1.0.0',
|
||
enabled: true,
|
||
description: '读取已配置 MCP 服务与工具，作为数字员工的工具能力池。',
|
||
category: '工具',
|
||
capability_level: 'core',
|
||
},
|
||
{
|
||
skill_id: 'qimingclaw-computer-control',
|
||
name: '客户端电脑控制',
|
||
version: '1.0.0',
|
||
enabled: true,
|
||
description: '承接 /computer/chat 执行入口，面向远程任务和本地自动化操作。',
|
||
category: '桌面',
|
||
capability_level: 'specialized',
|
||
},
|
||
{
|
||
skill_id: 'qimingclaw-artifact-report',
|
||
name: '产物与日报整理',
|
||
version: '1.0.0',
|
||
enabled: true,
|
||
description: '把执行记录、关键产物和异常汇总成数字员工日报。',
|
||
category: '汇报',
|
||
capability_level: 'standard',
|
||
},
|
||
];
|
||
|
||
const PLANS: DebugPlan[] = [
|
||
{
|
||
plan_id: 'qimingclaw-client-readiness',
|
||
title: '客户端运行状态巡检',
|
||
objective: '确认 qimingclaw 客户端、Agent、MCP 和远程接入能力是否处于可执行状态。',
|
||
status: 'running',
|
||
created_at: todayAt(9, 0),
|
||
steps: [
|
||
{
|
||
step_id: 'agent-status',
|
||
title: '检查 Agent 引擎状态',
|
||
depends_on: [],
|
||
preferred_skills: ['qimingclaw-acp-session'],
|
||
tasks: [{ task_id: 'task-agent-status', title: '读取 Agent 服务状态', status: 'running' }],
|
||
},
|
||
{
|
||
step_id: 'mcp-status',
|
||
title: '检查 MCP 工具能力',
|
||
depends_on: ['agent-status'],
|
||
preferred_skills: ['qimingclaw-mcp-tools'],
|
||
tasks: [{ task_id: 'task-mcp-status', title: '同步 MCP 工具列表', status: 'pending' }],
|
||
},
|
||
],
|
||
},
|
||
{
|
||
plan_id: 'qimingclaw-remote-task-ingress',
|
||
title: '远程任务接入准备',
|
||
objective: '检查 lanproxy、computer server 和文件服务，为后端下发数字员工任务做准备。',
|
||
status: 'pending',
|
||
created_at: todayAt(9, 30),
|
||
steps: [
|
||
{
|
||
step_id: 'computer-server',
|
||
title: '确认 /computer/chat 执行入口',
|
||
depends_on: [],
|
||
preferred_skills: ['qimingclaw-computer-control'],
|
||
tasks: [{ task_id: 'task-computer-server', title: '检查电脑控制服务', status: 'pending' }],
|
||
},
|
||
{
|
||
step_id: 'file-artifact',
|
||
title: '准备产物回传目录',
|
||
depends_on: ['computer-server'],
|
||
preferred_skills: ['qimingclaw-artifact-report'],
|
||
tasks: [{ task_id: 'task-file-artifact', title: '整理执行产物通道', status: 'pending' }],
|
||
},
|
||
],
|
||
},
|
||
{
|
||
plan_id: 'qimingclaw-daily-report',
|
||
title: '数字员工日报生成',
|
||
objective: '汇总今日执行记录、服务状态和待介入事项，生成面向业务的日报。',
|
||
status: 'pending',
|
||
created_at: todayAt(17, 30),
|
||
steps: [
|
||
{
|
||
step_id: 'collect-events',
|
||
title: '汇总运行事件',
|
||
depends_on: [],
|
||
preferred_skills: ['qimingclaw-artifact-report'],
|
||
tasks: [{ task_id: 'task-collect-events', title: '整理今日运行明细', status: 'pending' }],
|
||
},
|
||
{
|
||
step_id: 'write-report',
|
||
title: '生成日报摘要',
|
||
depends_on: ['collect-events'],
|
||
preferred_skills: ['qimingclaw-artifact-report'],
|
||
tasks: [{ task_id: 'task-write-report', title: '生成数字员工日报', status: 'pending' }],
|
||
},
|
||
],
|
||
},
|
||
];
|
||
|
||
const PLAN_SCHEDULES: Record<string, { expression: string; nextRun: string; scheduleText: string }> = {
|
||
'qimingclaw-client-readiness': {
|
||
expression: '0 9 * * *',
|
||
nextRun: todayAt(9, 0),
|
||
scheduleText: '已定时 09:00 执行',
|
||
},
|
||
'qimingclaw-remote-task-ingress': {
|
||
expression: '30 9 * * *',
|
||
nextRun: todayAt(9, 30),
|
||
scheduleText: '已定时 09:30 执行',
|
||
},
|
||
'qimingclaw-daily-report': {
|
||
expression: '0 18 * * *',
|
||
nextRun: todayAt(18, 0),
|
||
scheduleText: '已定时 18:00 执行',
|
||
},
|
||
};
|
||
|
||
const BUSINESS_VIEW_SOURCE = 'qimingclaw-runtime-projection';
|
||
|
||
type BusinessViewKind = 'plans' | 'plan-steps' | 'plan-step-graph' | 'tasks' | 'runs' | 'events' | 'artifacts' | 'approvals' | 'approval-history' | 'route-decisions' | 'notifications' | 'audits';
|
||
type BusinessViewRow = Record<string, unknown>;
|
||
|
||
export function isQimingclawDigitalApiEnabled(): boolean {
|
||
return window.__QIMINGCLAW_EMBEDDED_DIGITAL__ === true;
|
||
}
|
||
|
||
export async function handleQimingclawDigitalApi<T>(
|
||
path: string,
|
||
options: RequestInit = {},
|
||
): Promise<T | undefined> {
|
||
if (!isQimingclawDigitalApiEnabled()) return undefined;
|
||
|
||
const url = new URL(path, window.location.origin);
|
||
const method = (options.method || 'GET').toUpperCase();
|
||
const pathname = url.pathname;
|
||
|
||
if (method === 'GET' && pathname === '/api/digital-employee/workday') {
|
||
return buildWorkday(url.searchParams.get('date') || todayInputDate(), await readQimingclawSnapshot()) as T;
|
||
}
|
||
if (method === 'POST' && pathname === '/api/digital-employee/workday/actions') {
|
||
return await handleWorkdayAction(parseJsonBody<DigitalEmployeeWorkdayActionRequest>(options.body), await readQimingclawSnapshot()) as T;
|
||
}
|
||
const managedServiceRestartMatch = pathname.match(/^\/api\/(?:digital-employee\/)?managed-services\/([^/]+)\/restart$/);
|
||
if (method === 'POST' && managedServiceRestartMatch) {
|
||
return await handleManagedServiceRestart(
|
||
decodeURIComponent(managedServiceRestartMatch[1] || ''),
|
||
parseOptionalJsonBody(options.body),
|
||
) as T;
|
||
}
|
||
const dailyReportDetailMatch = pathname.match(/^\/api\/digital-employee\/daily-reports\/([^/]+)$/);
|
||
if (method === 'GET' && dailyReportDetailMatch) {
|
||
const reportId = decodeURIComponent(dailyReportDetailMatch[1] || '');
|
||
const item = dailyReportRows(await readQimingclawSnapshot())
|
||
.find((row) => stringValue(row.report_id) === reportId || stringValue(row.artifact_id) === reportId) ?? null;
|
||
return { item, source: BUSINESS_VIEW_SOURCE } as T;
|
||
}
|
||
if (method === 'GET' && pathname === '/api/digital-employee/daily-reports') {
|
||
const rows = filterDailyReportRows(dailyReportRows(await readQimingclawSnapshot()), url.searchParams);
|
||
return { ...paginateBusinessRows(rows, url.searchParams), source: BUSINESS_VIEW_SOURCE } as T;
|
||
}
|
||
if (method === 'GET' && pathname === '/api/digital-employee/skill-call-audits') {
|
||
const rows = filterSkillCallAuditRows(skillCallAuditRows(await readQimingclawSnapshot()), url.searchParams);
|
||
return { ...paginateBusinessRows(rows, url.searchParams), source: BUSINESS_VIEW_SOURCE } as T;
|
||
}
|
||
if (method === 'GET' && pathname === '/api/digital-employee/artifact-access-events') {
|
||
const rows = filterArtifactAccessRows(artifactAccessRows(await readQimingclawSnapshot()), url.searchParams);
|
||
return { ...paginateBusinessRows(rows, url.searchParams), source: BUSINESS_VIEW_SOURCE } as T;
|
||
}
|
||
const artifactAccessMatch = pathname.match(/^\/api\/(?:digital-employee\/artifacts|artifact)\/([^/]+)\/access$/);
|
||
if (method === 'POST' && artifactAccessMatch) {
|
||
const artifactId = decodeURIComponent(artifactAccessMatch[1] || '');
|
||
return await handleArtifactAccess(artifactId, parseOptionalJsonBody(options.body)) as T;
|
||
}
|
||
const artifactRetentionMatch = pathname.match(/^\/api\/digital-employee\/artifacts\/([^/]+)\/retention$/);
|
||
if (method === 'POST' && artifactRetentionMatch) {
|
||
const artifactId = decodeURIComponent(artifactRetentionMatch[1] || '');
|
||
return await handleArtifactRetention(artifactId, parseOptionalJsonBody(options.body), await readQimingclawSnapshot()) as T;
|
||
}
|
||
const artifactVersionsMatch = pathname.match(/^\/api\/digital-employee\/artifacts\/([^/]+)\/versions$/);
|
||
if (method === 'GET' && artifactVersionsMatch) {
|
||
const artifactId = decodeURIComponent(artifactVersionsMatch[1] || '');
|
||
const snapshot = await readQimingclawSnapshot();
|
||
return { items: artifactVersionRows(snapshot, artifactId), source: BUSINESS_VIEW_SOURCE } as T;
|
||
}
|
||
const artifactDetailMatch = pathname.match(/^\/api\/digital-employee\/artifacts\/([^/]+)$/);
|
||
if (method === 'GET' && artifactDetailMatch) {
|
||
const artifactId = decodeURIComponent(artifactDetailMatch[1] || '');
|
||
const snapshot = await readQimingclawSnapshot();
|
||
const item = artifactDetailRow(snapshot, artifactId);
|
||
return { item, source: BUSINESS_VIEW_SOURCE } as T;
|
||
}
|
||
const businessPlanDetailMatch = pathname.match(/^\/api\/digital-employee\/plans\/([^/]+)$/);
|
||
if (method === 'GET' && businessPlanDetailMatch) {
|
||
const planId = decodeURIComponent(businessPlanDetailMatch[1] || '');
|
||
const item = businessPlanRows(await readQimingclawSnapshot())
|
||
.find((row) => stringValue(row.plan_id) === planId || stringValue(row.remote_id) === planId) ?? null;
|
||
return { item, source: BUSINESS_VIEW_SOURCE } as T;
|
||
}
|
||
const approvalActionMatch = pathname.match(/^\/api\/digital-employee\/approvals\/([^/]+)\/actions$/);
|
||
if (method === 'POST' && approvalActionMatch) {
|
||
const approvalId = decodeURIComponent(approvalActionMatch[1] || '');
|
||
return await handleApprovalAction(approvalId, parseOptionalJsonBody(options.body), await readQimingclawSnapshot()) as T;
|
||
}
|
||
if (method === 'GET' && pathname === '/api/approval/subscriptions') {
|
||
return approvalSubscriptionPreferences(notificationAdapterState(await readQimingclawSnapshot())) as T;
|
||
}
|
||
if (method === 'PATCH' && pathname === '/api/approval/subscriptions') {
|
||
return await handleApprovalSubscriptionPreferencesPatch(
|
||
parseJsonBody<Partial<ApprovalSubscriptionPreferences>>(options.body),
|
||
await readQimingclawSnapshot(),
|
||
) as T;
|
||
}
|
||
if (method === 'GET' && pathname === '/api/plan-step/dispatch-policy') {
|
||
return planStepDispatchPolicy(notificationAdapterState(await readQimingclawSnapshot())) as T;
|
||
}
|
||
if (method === 'PATCH' && pathname === '/api/plan-step/dispatch-policy') {
|
||
return await handlePlanStepDispatchPolicyPatch(
|
||
parseJsonBody<Partial<PlanStepDispatchPolicy>>(options.body),
|
||
await readQimingclawSnapshot(),
|
||
) as T;
|
||
}
|
||
if (method === 'GET' && pathname === '/api/digital-employee/plan-steps') {
|
||
const rows = filterPlanStepRows(planStepRows(await readQimingclawSnapshot()), url.searchParams);
|
||
return { ...paginateBusinessRows(rows, url.searchParams), source: BUSINESS_VIEW_SOURCE } as T;
|
||
}
|
||
if (method === 'GET' && pathname === '/api/digital-employee/plan-step-graph') {
|
||
const rows = filterPlanStepRows(planStepGraphRows(await readQimingclawSnapshot()), url.searchParams);
|
||
return { ...paginateBusinessRows(rows, url.searchParams), source: BUSINESS_VIEW_SOURCE } as T;
|
||
}
|
||
if (method === 'GET' && pathname === '/api/digital-employee/approval-history') {
|
||
const rows = filterApprovalHistoryRows(approvalHistoryRows(await readQimingclawSnapshot()), url.searchParams);
|
||
return { ...paginateBusinessRows(rows, url.searchParams), source: BUSINESS_VIEW_SOURCE } as T;
|
||
}
|
||
const businessViewMatch = pathname.match(/^\/api\/digital-employee\/(plans|plan-steps|plan-step-graph|tasks|runs|events|artifacts|approvals|approval-history|route-decisions|notifications|audits)$/);
|
||
if (method === 'GET' && businessViewMatch) {
|
||
return buildBusinessViewResponse(businessViewMatch[1] as BusinessViewKind, await readQimingclawSnapshot(), url.searchParams) as T;
|
||
}
|
||
if (method === 'GET' && pathname === '/api/route-decisions') {
|
||
return await readRouteDecisions(Number(url.searchParams.get('limit')) || 80) as T;
|
||
}
|
||
if (method === 'POST' && pathname === '/api/ingress/route') {
|
||
return await handleIngressRoute(parseJsonBody<IngressRouteRequest>(options.body), await readQimingclawSnapshot()) as T;
|
||
}
|
||
if (method === 'POST' && pathname === '/api/governance/command') {
|
||
return await handleGovernanceCommand(parseJsonBody<GovernanceCommandRequest>(options.body), await readQimingclawSnapshot()) as T;
|
||
}
|
||
if (method === 'GET' && pathname === '/api/scheduler/jobs') {
|
||
return { jobs: buildSchedulerJobs(await readQimingclawSnapshot()) } as T;
|
||
}
|
||
if (method === 'GET' && pathname === '/api/cron') {
|
||
return { jobs: buildSchedulerJobs(await readQimingclawSnapshot()) } as T;
|
||
}
|
||
if (method === 'POST' && pathname === '/api/cron') {
|
||
return await handleCronCreate(parseJsonBody<Record<string, unknown>>(options.body), await readQimingclawSnapshot()) as T;
|
||
}
|
||
if (method === 'GET' && pathname === '/api/cron/settings') {
|
||
return await readCronSettings() as T;
|
||
}
|
||
if (method === 'PATCH' && pathname === '/api/cron/settings') {
|
||
const patch = parseJsonBody<Partial<QimingclawCronSettings>>(options.body);
|
||
return await saveCronSettings(patch) as T;
|
||
}
|
||
if (method === 'POST' && pathname === '/api/cron/check') {
|
||
const result = await window.QimingClawBridge?.digital?.runSchedulerCheck?.();
|
||
return { ok: true, activated: result?.activated ?? 0, ...result } as T;
|
||
}
|
||
const cronRunMatch = pathname.match(/^\/api\/cron\/([^/]+)\/runs$/);
|
||
if (method === 'GET' && cronRunMatch) {
|
||
const runs = await readCronRuns(decodeURIComponent(cronRunMatch[1] || ''), Number(url.searchParams.get('limit')) || 20);
|
||
return { runs } as T;
|
||
}
|
||
const cronJobMatch = pathname.match(/^\/api\/cron\/([^/]+)$/);
|
||
if ((method === 'PATCH' || method === 'DELETE') && cronJobMatch) {
|
||
const scheduleId = decodeURIComponent(cronJobMatch[1] || '');
|
||
if (method === 'DELETE') {
|
||
await handleCronCommand('delete_schedule', scheduleId, {}, await readQimingclawSnapshot());
|
||
return undefined as T;
|
||
}
|
||
return await handleCronPatch(scheduleId, parseJsonBody<Record<string, unknown>>(options.body), await readQimingclawSnapshot()) as T;
|
||
}
|
||
if (method === 'GET' && pathname === '/api/debug/plans') {
|
||
return { plans: filterPlans(url.searchParams.get('q'), await readQimingclawSnapshot()) } as T;
|
||
}
|
||
if (method === 'GET' && pathname === '/api/debug/tasks') {
|
||
const planId = url.searchParams.get('plan_id');
|
||
return buildTasksResponse(planId, await readQimingclawSnapshot()) as T;
|
||
}
|
||
if (method === 'GET' && pathname === '/api/debug/store') {
|
||
return buildDebugStore(await readQimingclawSnapshot()) as T;
|
||
}
|
||
if (method === 'GET' && pathname === '/api/dashboard') {
|
||
return buildDashboard(await readQimingclawSnapshot()) as T;
|
||
}
|
||
if ((method === 'GET' || method === 'POST') && pathname === '/api/doctor') {
|
||
return buildDoctor(await readQimingclawSnapshot()) as T;
|
||
}
|
||
if (method === 'GET' && pathname === '/api/cost') {
|
||
return { cost: buildCostSummary(await readQimingclawSnapshot()) } as T;
|
||
}
|
||
if (method === 'GET' && pathname === '/api/audit') {
|
||
return { events: buildAuditEvents(await readQimingclawSnapshot(), url.searchParams) } as T;
|
||
}
|
||
if (method === 'GET' && pathname === '/api/artifact') {
|
||
return { artifacts: buildArtifacts(await readQimingclawSnapshot()) } as T;
|
||
}
|
||
const approvalTimelineMatch = pathname.match(/^\/api\/approval\/([^/]+)\/timeline$/);
|
||
if (method === 'GET' && approvalTimelineMatch) {
|
||
return buildApprovalTimeline(decodeURIComponent(approvalTimelineMatch[1] || ''), await readQimingclawSnapshot()) as T;
|
||
}
|
||
if (method === 'GET' && pathname === '/api/notifications') {
|
||
return buildNotificationsResponse(url.searchParams.get('status'), await readQimingclawSnapshot()) as T;
|
||
}
|
||
if (method === 'GET' && pathname === '/api/notifications/preferences') {
|
||
return notificationPreferences(notificationAdapterState(await readQimingclawSnapshot())) as T;
|
||
}
|
||
if (method === 'PATCH' && pathname === '/api/notifications/preferences') {
|
||
return await handleNotificationPreferencesPatch(
|
||
parseJsonBody<Partial<NotificationPreferences>>(options.body),
|
||
await readQimingclawSnapshot(),
|
||
) as T;
|
||
}
|
||
if (method === 'GET' && pathname === '/api/notifications/unread-count') {
|
||
const snapshot = await readQimingclawSnapshot();
|
||
return { count: buildNotifications(snapshot, notificationAdapterState(snapshot)).filter((notification) => notification.status === 'unread').length } as T;
|
||
}
|
||
const notificationActionMatch = pathname.match(/^\/api\/notifications\/([^/]+)\/(read|dismiss|reply)$/);
|
||
if (method === 'POST' && notificationActionMatch) {
|
||
return await handleNotificationAction(
|
||
decodeURIComponent(notificationActionMatch[1] || ''),
|
||
notificationActionMatch[2] as 'read' | 'dismiss' | 'reply',
|
||
parseOptionalJsonBody(options.body),
|
||
await readQimingclawSnapshot(),
|
||
) as T;
|
||
}
|
||
if (method === 'GET' && pathname === '/api/memory') {
|
||
return { entries: await readMemoryEntries(url.searchParams.get('query'), url.searchParams.get('category')) } as T;
|
||
}
|
||
if (method === 'POST' && pathname === '/api/memory') {
|
||
return await handleMemoryCreate(parseJsonBody<Record<string, unknown>>(options.body)) as T;
|
||
}
|
||
const memoryDeleteMatch = pathname.match(/^\/api\/memory\/([^/]+)$/);
|
||
if (method === 'DELETE' && memoryDeleteMatch) {
|
||
await handleMemoryDelete(decodeURIComponent(memoryDeleteMatch[1] || ''));
|
||
return undefined as T;
|
||
}
|
||
if (method === 'GET' && pathname.startsWith('/api/debug/plan/') && pathname.endsWith('/flow')) {
|
||
return buildPlanFlow(decodeURIComponent(pathname.split('/')[4] || ''), await readQimingclawSnapshot()) as T;
|
||
}
|
||
if (method === 'GET' && pathname.startsWith('/api/debug/task/') && pathname.endsWith('/flow')) {
|
||
return buildTaskFlow(decodeURIComponent(pathname.split('/')[4] || ''), await readQimingclawSnapshot()) as T;
|
||
}
|
||
const planReadyDispatchMatch = pathname.match(/^\/api\/digital-employee\/plans\/([^/]+)\/dispatch-ready-steps$/);
|
||
if (method === 'POST' && planReadyDispatchMatch) {
|
||
return await dispatchPlanReadySteps(decodeURIComponent(planReadyDispatchMatch[1] || ''), await readQimingclawSnapshot()) as T;
|
||
}
|
||
if (method === 'POST' && pathname.startsWith('/api/debug/plan/') && pathname.endsWith('/dispatch')) {
|
||
return await dispatchPlan(decodeURIComponent(pathname.split('/')[4] || ''), await readQimingclawSnapshot()) as T;
|
||
}
|
||
const debugPlanActionMatch = pathname.match(/^\/api\/debug\/plan\/([^/]+)\/([^/]+)$/);
|
||
if (method === 'POST' && debugPlanActionMatch) {
|
||
return await handlePlanAction(
|
||
decodeURIComponent(debugPlanActionMatch[1] || ''),
|
||
decodeURIComponent(debugPlanActionMatch[2] || ''),
|
||
await readQimingclawSnapshot(),
|
||
parseOptionalJsonBody(options.body),
|
||
) as T;
|
||
}
|
||
const planSubmitMatch = pathname.match(/^\/api\/plan\/([^/]+)\/submit$/);
|
||
if (method === 'POST' && planSubmitMatch) {
|
||
return await handlePlanAction(
|
||
decodeURIComponent(planSubmitMatch[1] || ''),
|
||
'submit',
|
||
await readQimingclawSnapshot(),
|
||
parseOptionalJsonBody(options.body),
|
||
) as T;
|
||
}
|
||
if (method === 'GET' && pathname.startsWith('/api/plan/') && pathname.endsWith('/revisions')) {
|
||
return buildPlanRevisions(decodeURIComponent(pathname.split('/')[3] || ''), await readQimingclawSnapshot()) as T;
|
||
}
|
||
const taskActionMatch = pathname.match(/^\/api\/task\/([^/]+)\/([^/]+)$/);
|
||
if (method === 'POST' && taskActionMatch) {
|
||
return await handleTaskAction(
|
||
decodeURIComponent(taskActionMatch[1] || ''),
|
||
decodeURIComponent(taskActionMatch[2] || ''),
|
||
await readQimingclawSnapshot(),
|
||
parseOptionalJsonBody(options.body),
|
||
) as T;
|
||
}
|
||
if (method === 'GET' && pathname.startsWith('/api/plan/') && pathname.endsWith('/messages')) {
|
||
return { messages: buildPlanMessages(decodeURIComponent(pathname.split('/')[3] || ''), await readQimingclawSnapshot()) } as T;
|
||
}
|
||
if (method === 'GET' && pathname === '/api/skill') {
|
||
return { skills: await buildSkills() } as T;
|
||
}
|
||
if (method === 'POST' && pathname.startsWith('/api/skill/') && pathname.endsWith('/enabled')) {
|
||
const skillId = decodeURIComponent(pathname.split('/')[3] || '');
|
||
const body = parseJsonBody<{ enabled?: boolean }>(options.body);
|
||
return await setBridgeSkillEnabled(skillId, body.enabled ?? true) as T;
|
||
}
|
||
|
||
return undefined;
|
||
}
|
||
|
||
function defaultState(): AdapterState {
|
||
return {
|
||
selectedDutyIdsByDate: {},
|
||
confirmedDates: {},
|
||
reportScheduleTime: DEFAULT_REPORT_TIME,
|
||
reportGeneratedAtByDate: {},
|
||
decisionResultsByDate: {},
|
||
notificationStateById: {},
|
||
notificationPreferences: defaultNotificationPreferences(),
|
||
approvalSubscriptionPreferences: defaultApprovalSubscriptionPreferences(),
|
||
planStepDispatchPolicy: defaultPlanStepDispatchPolicy(),
|
||
consoleRole: 'sales',
|
||
rolePreferences: {},
|
||
profile: {
|
||
name: '飞天数字员工',
|
||
company: 'qimingclaw 客户端',
|
||
position: '客户端任务执行员',
|
||
currentStatus: 'working',
|
||
},
|
||
};
|
||
}
|
||
|
||
function readState(): AdapterState {
|
||
try {
|
||
const raw = window.localStorage.getItem(STATE_KEY);
|
||
return normalizeAdapterState(raw ? JSON.parse(raw) as Partial<AdapterState> : {});
|
||
} catch {
|
||
return defaultState();
|
||
}
|
||
}
|
||
|
||
function normalizeAdapterState(value: Partial<AdapterState>): AdapterState {
|
||
return {
|
||
...defaultState(),
|
||
...value,
|
||
notificationPreferences: notificationPreferences(value),
|
||
approvalSubscriptionPreferences: approvalSubscriptionPreferences(value),
|
||
planStepDispatchPolicy: planStepDispatchPolicy(value),
|
||
};
|
||
}
|
||
|
||
function writeState(state: AdapterState): void {
|
||
window.localStorage.setItem(STATE_KEY, JSON.stringify(state));
|
||
}
|
||
|
||
async function readQimingclawSnapshot(): Promise<QimingclawSnapshot | null> {
|
||
try {
|
||
const snapshot = await window.QimingClawBridge?.digital?.getSnapshot?.() ?? null;
|
||
if (!snapshot) return null;
|
||
const [sync, runtime, uiState, planTemplates] = await Promise.all([
|
||
window.QimingClawBridge?.digital?.getSyncStatus?.().catch(() => null) ?? null,
|
||
window.QimingClawBridge?.digital?.getRuntimeRecords?.().catch(() => null) ?? null,
|
||
readBridgeUiState(),
|
||
window.QimingClawBridge?.digital?.getPlanTemplates?.().catch(() => null) ?? null,
|
||
]);
|
||
return { ...snapshot, sync, runtime, uiState, planTemplates: planTemplates?.templates ?? [] };
|
||
} catch {
|
||
return null;
|
||
}
|
||
}
|
||
|
||
async function readBridgeUiState(): Promise<AdapterState | null> {
|
||
try {
|
||
return await window.QimingClawBridge?.digital?.getUiState?.() ?? null;
|
||
} catch {
|
||
return null;
|
||
}
|
||
}
|
||
|
||
async function readBridgeSkillCapabilities(): Promise<SkillSpec[]> {
|
||
try {
|
||
const result = await window.QimingClawBridge?.digital?.getSkillCapabilities?.() ?? null;
|
||
return Array.isArray(result?.skills) ? result.skills : [];
|
||
} catch {
|
||
return [];
|
||
}
|
||
}
|
||
|
||
async function buildSkills(): Promise<SkillSpec[]> {
|
||
const bridgeSkills = await readBridgeSkillCapabilities();
|
||
return dedupeSkills([...bridgeSkills, ...SKILLS]);
|
||
}
|
||
|
||
async function setBridgeSkillEnabled(
|
||
skillId: string,
|
||
enabled: boolean,
|
||
): Promise<{ ok: boolean; skill_id: string; enabled: boolean; error?: string }> {
|
||
const bridge = window.QimingClawBridge?.digital;
|
||
if (!bridge?.setSkillEnabled) {
|
||
return { ok: false, skill_id: skillId, enabled, error: 'qimingclaw_bridge_unavailable' };
|
||
}
|
||
try {
|
||
const result = await bridge.setSkillEnabled(skillId, enabled);
|
||
return {
|
||
ok: result?.ok !== false,
|
||
skill_id: result?.skill_id ?? skillId,
|
||
enabled: result?.enabled ?? enabled,
|
||
...(result?.error ? { error: result.error } : {}),
|
||
};
|
||
} catch (error) {
|
||
return {
|
||
ok: false,
|
||
skill_id: skillId,
|
||
enabled,
|
||
error: error instanceof Error ? error.message : String(error),
|
||
};
|
||
}
|
||
}
|
||
|
||
function dedupeSkills(skills: SkillSpec[]): SkillSpec[] {
|
||
const seen = new Set<string>();
|
||
const result: SkillSpec[] = [];
|
||
for (const skill of skills) {
|
||
const skillId = typeof skill.skill_id === 'string' ? skill.skill_id.trim() : '';
|
||
if (!skillId || seen.has(skillId)) continue;
|
||
seen.add(skillId);
|
||
result.push({ ...skill, skill_id: skillId });
|
||
}
|
||
return result;
|
||
}
|
||
|
||
async function saveState(
|
||
state: AdapterState,
|
||
action?: string,
|
||
date?: string,
|
||
metadata?: Record<string, unknown>,
|
||
): Promise<AdapterState> {
|
||
writeState(state);
|
||
try {
|
||
return await window.QimingClawBridge?.digital?.saveUiState?.({ state, action, date, metadata }) ?? state;
|
||
} catch {
|
||
return state;
|
||
}
|
||
}
|
||
|
||
async function recordGovernanceCommand(
|
||
body: GovernanceCommandRequest,
|
||
response: GovernanceCommandResponse,
|
||
): Promise<void> {
|
||
try {
|
||
await window.QimingClawBridge?.digital?.recordGovernanceCommand?.({
|
||
commandKind: body.command_kind,
|
||
commandId: response.command_id,
|
||
correlationId: response.correlation_id,
|
||
planId: stringFromUnknown(response.result?.plan_id)
|
||
|| stringFromUnknown(body.context_refs?.plan_id)
|
||
|| stringFromUnknown(body.payload?.plan_id)
|
||
|| null,
|
||
taskId: stringFromUnknown(response.result?.task_id)
|
||
|| stringFromUnknown(body.context_refs?.task_id)
|
||
|| stringFromUnknown(body.payload?.task_id)
|
||
|| null,
|
||
runId: stringFromUnknown(response.result?.run_id)
|
||
|| stringFromUnknown(body.context_refs?.run_id)
|
||
|| stringFromUnknown(body.payload?.run_id)
|
||
|| stringFromUnknown(body.payload?.latest_run_id)
|
||
|| null,
|
||
stepId: stringFromUnknown(response.result?.step_id)
|
||
|| stringFromUnknown(body.context_refs?.step_id)
|
||
|| stringFromUnknown(body.payload?.step_id)
|
||
|| stringFromUnknown(body.payload?.stepId)
|
||
|| null,
|
||
scheduleId: stringFromUnknown(response.result?.schedule_id)
|
||
|| stringFromUnknown(body.context_refs?.schedule_id)
|
||
|| stringFromUnknown(body.payload?.schedule_id)
|
||
|| null,
|
||
accepted: response.accepted,
|
||
message: response.message,
|
||
error: response.error ?? null,
|
||
payload: body.payload ?? null,
|
||
result: response.result ?? null,
|
||
});
|
||
} catch {
|
||
// Bridge persistence is best-effort; the adapter response should not block UI flow.
|
||
}
|
||
}
|
||
|
||
async function readCronSettings(): Promise<QimingclawCronSettings> {
|
||
try {
|
||
return await window.QimingClawBridge?.digital?.getCronSettings?.() ?? defaultCronSettings();
|
||
} catch {
|
||
return defaultCronSettings();
|
||
}
|
||
}
|
||
|
||
async function saveCronSettings(patch: Partial<QimingclawCronSettings>): Promise<QimingclawCronSettings> {
|
||
try {
|
||
return await window.QimingClawBridge?.digital?.saveCronSettings?.(patch) ?? { ...defaultCronSettings(), ...patch };
|
||
} catch {
|
||
return { ...defaultCronSettings(), ...patch };
|
||
}
|
||
}
|
||
|
||
async function readMemoryEntries(query?: string | null, category?: string | null): Promise<MemoryEntry[]> {
|
||
try {
|
||
const records = await window.QimingClawBridge?.digital?.listMemories?.({
|
||
query: query || undefined,
|
||
category: category || undefined,
|
||
limit: 300,
|
||
}) ?? [];
|
||
return records.map(memoryEntryFromRecord);
|
||
} catch {
|
||
return [];
|
||
}
|
||
}
|
||
|
||
async function handleMemoryCreate(body: Record<string, unknown>): Promise<{ ok: true; entry: MemoryEntry | null }> {
|
||
const key = stringFromUnknown(body.key);
|
||
const content = stringFromUnknown(body.content ?? body.text);
|
||
const category = stringFromUnknown(body.category) || 'fact';
|
||
if (!content) return { ok: true, entry: null };
|
||
const record = await window.QimingClawBridge?.digital?.addMemory?.({
|
||
key: key || undefined,
|
||
content,
|
||
category,
|
||
source: 'qimingclaw-digital-page',
|
||
payload: {
|
||
source: 'embedded-memory-api',
|
||
key: key || null,
|
||
},
|
||
}) ?? null;
|
||
return { ok: true, entry: record ? memoryEntryFromRecord(record) : null };
|
||
}
|
||
|
||
async function handleMemoryDelete(keyOrId: string): Promise<void> {
|
||
try {
|
||
await window.QimingClawBridge?.digital?.deleteMemory?.(keyOrId);
|
||
} catch {
|
||
// Keep the DELETE endpoint best-effort so the UI can refresh into the true state.
|
||
}
|
||
}
|
||
|
||
function memoryEntryFromRecord(record: QimingclawMemoryRecord): MemoryEntry {
|
||
return {
|
||
id: record.id,
|
||
key: record.key || record.id,
|
||
content: record.content,
|
||
category: record.category || 'fact',
|
||
timestamp: record.updatedAt || record.createdAt || new Date().toISOString(),
|
||
session_id: record.sessionId ?? null,
|
||
score: typeof record.score === 'number' ? record.score : null,
|
||
};
|
||
}
|
||
|
||
function defaultCronSettings(): QimingclawCronSettings {
|
||
return {
|
||
enabled: true,
|
||
catch_up_on_startup: true,
|
||
max_run_history: 100,
|
||
max_catch_up_runs: 5,
|
||
max_concurrent_schedule_runs: 1,
|
||
};
|
||
}
|
||
|
||
async function handleCronCreate(
|
||
body: Record<string, unknown>,
|
||
snapshot: QimingclawSnapshot | null,
|
||
): Promise<{ status: string; job: CronJob }> {
|
||
const stamp = Date.now();
|
||
const scheduleId = stringFromUnknown(body.id) || stringFromUnknown(body.schedule_id) || `cron-${slugifyIdPart(stringFromUnknown(body.name) || 'job')}-${stamp}`;
|
||
await handleGovernanceCommand({
|
||
command_kind: 'create_schedule',
|
||
context_refs: { schedule_id: scheduleId, plan_id: stringFromUnknown(body.plan_id) || stringFromUnknown(body.template_id) || undefined },
|
||
payload: {
|
||
...body,
|
||
schedule_id: scheduleId,
|
||
cron_expr: stringFromUnknown(body.schedule) || stringFromUnknown(body.cron_expr),
|
||
},
|
||
correlation_id: `qimingclaw-cron-create-${stamp}`,
|
||
idempotency_key: `qimingclaw-cron-create-${scheduleId}-${stamp}`,
|
||
}, snapshot);
|
||
const refreshed = await readQimingclawSnapshot();
|
||
return { status: 'created', job: buildSchedulerJobs(refreshed).find((job) => job.id === scheduleId) ?? cronJobFromBody(scheduleId, body) };
|
||
}
|
||
|
||
async function handleCronPatch(
|
||
scheduleId: string,
|
||
patch: Record<string, unknown>,
|
||
snapshot: QimingclawSnapshot | null,
|
||
): Promise<{ status: string; job: CronJob }> {
|
||
await handleCronCommand('update_schedule', scheduleId, patch, snapshot);
|
||
const refreshed = await readQimingclawSnapshot();
|
||
return { status: 'updated', job: buildSchedulerJobs(refreshed).find((job) => job.id === scheduleId) ?? cronJobFromBody(scheduleId, patch) };
|
||
}
|
||
|
||
async function handleCronCommand(
|
||
commandKind: GovernanceCommandRequest['command_kind'],
|
||
scheduleId: string,
|
||
payload: Record<string, unknown>,
|
||
snapshot: QimingclawSnapshot | null,
|
||
): Promise<GovernanceCommandResponse> {
|
||
const stamp = Date.now();
|
||
return handleGovernanceCommand({
|
||
command_kind: commandKind,
|
||
context_refs: { schedule_id: scheduleId, plan_id: stringFromUnknown(payload.plan_id) || stringFromUnknown(payload.template_id) || undefined },
|
||
payload: {
|
||
...payload,
|
||
schedule_id: scheduleId,
|
||
cron_expr: stringFromUnknown(payload.schedule) || stringFromUnknown(payload.cron_expr),
|
||
},
|
||
correlation_id: `qimingclaw-cron-${commandKind}-${stamp}`,
|
||
idempotency_key: `qimingclaw-cron-${commandKind}-${scheduleId}-${stamp}`,
|
||
}, snapshot);
|
||
}
|
||
|
||
function cronJobFromBody(id: string, body: Record<string, unknown>): CronJob {
|
||
const now = new Date().toISOString();
|
||
const expression = stringFromUnknown(body.schedule) || stringFromUnknown(body.cron_expr) || '0 9 * * *';
|
||
return {
|
||
id,
|
||
name: stringFromUnknown(body.name) || id,
|
||
expression,
|
||
command: stringFromUnknown(body.command) || `digital-employee:${id}`,
|
||
prompt: stringFromUnknown(body.prompt) || null,
|
||
job_type: stringFromUnknown(body.job_type) || 'qimingclaw_schedule',
|
||
schedule: { expression, schedule_id: id },
|
||
enabled: body.enabled !== false,
|
||
delivery: { mode: 'qimingclaw_schedule', schedule_id: id },
|
||
template_id: stringFromUnknown(body.template_id) || stringFromUnknown(body.plan_id) || id,
|
||
trigger_kind: 'scheduled',
|
||
delete_after_run: body.delete_after_run === true,
|
||
created_at: now,
|
||
next_run: now,
|
||
last_run: null,
|
||
last_status: null,
|
||
last_output: null,
|
||
};
|
||
}
|
||
|
||
async function readCronRuns(scheduleId: string, limit: number): Promise<CronRun[]> {
|
||
const runs = await window.QimingClawBridge?.digital?.getScheduleRuns?.(scheduleId, limit).catch(() => []) ?? [];
|
||
return runs.map((run, index) => ({
|
||
id: Number.isFinite(Date.parse(run.createdAt)) ? Date.parse(run.createdAt) + index : index + 1,
|
||
job_id: run.scheduleId,
|
||
started_at: run.startedAt || run.createdAt,
|
||
finished_at: run.finishedAt || '',
|
||
status: run.status,
|
||
output: run.error || null,
|
||
duration_ms: run.startedAt && run.finishedAt
|
||
? Math.max(0, Date.parse(run.finishedAt) - Date.parse(run.startedAt))
|
||
: null,
|
||
}));
|
||
}
|
||
|
||
function parseJsonBody<T>(body: BodyInit | null | undefined): T {
|
||
if (typeof body !== 'string' || !body.trim()) return {} as T;
|
||
return JSON.parse(body) as T;
|
||
}
|
||
|
||
function parseOptionalJsonBody(body: BodyInit | null | undefined): Record<string, unknown> {
|
||
return parseJsonBody<Record<string, unknown>>(body);
|
||
}
|
||
|
||
function todayInputDate(): string {
|
||
const date = new Date();
|
||
return [
|
||
date.getFullYear(),
|
||
String(date.getMonth() + 1).padStart(2, '0'),
|
||
String(date.getDate()).padStart(2, '0'),
|
||
].join('-');
|
||
}
|
||
|
||
function todayAt(hour: number, minute: number): string {
|
||
const date = new Date();
|
||
date.setHours(hour, minute, 0, 0);
|
||
return date.toISOString();
|
||
}
|
||
|
||
function displayDate(date: string): string {
|
||
return date.split('-').join('/');
|
||
}
|
||
|
||
function formatTime(value?: string | null): string {
|
||
if (!value) return '未知';
|
||
const date = new Date(value);
|
||
if (Number.isNaN(date.getTime())) return value;
|
||
return new Intl.DateTimeFormat('zh-CN', {
|
||
hour: '2-digit',
|
||
minute: '2-digit',
|
||
}).format(date);
|
||
}
|
||
|
||
function selectedSetForDate(state: AdapterState, date: string): Set<string> {
|
||
return new Set(state.selectedDutyIdsByDate[date] ?? []);
|
||
}
|
||
|
||
function planStatusTone(status: string): string {
|
||
if (['completed', 'succeeded', 'success'].includes(status)) return 'success';
|
||
if (['running', 'active'].includes(status)) return 'running';
|
||
if (['failed', 'error'].includes(status)) return 'danger';
|
||
return 'waiting';
|
||
}
|
||
|
||
function isRunning(snapshot: QimingclawSnapshot | null, key: string): boolean {
|
||
return snapshot?.services[key]?.running === true;
|
||
}
|
||
|
||
function serviceError(snapshot: QimingclawSnapshot | null, key: string): string | undefined {
|
||
return snapshot?.services[key]?.error;
|
||
}
|
||
|
||
function runtimeStatusForPlan(plan: DebugPlan, snapshot: QimingclawSnapshot | null): string {
|
||
if (!snapshot) return plan.status;
|
||
if (plan.plan_id === 'qimingclaw-client-readiness') {
|
||
if (isRunning(snapshot, 'agent') && isRunning(snapshot, 'mcp')) return 'running';
|
||
if (serviceError(snapshot, 'agent') || serviceError(snapshot, 'mcp')) return 'failed';
|
||
return 'pending';
|
||
}
|
||
if (plan.plan_id === 'qimingclaw-remote-task-ingress') {
|
||
if (isRunning(snapshot, 'computerServer') || isRunning(snapshot, 'lanproxy') || isRunning(snapshot, 'fileServer')) return 'running';
|
||
if (serviceError(snapshot, 'computerServer') || serviceError(snapshot, 'lanproxy') || serviceError(snapshot, 'fileServer')) return 'failed';
|
||
return 'pending';
|
||
}
|
||
return plan.status;
|
||
}
|
||
|
||
function serviceLine(snapshot: QimingclawSnapshot | null, key: string, label: string): string {
|
||
const service = snapshot?.services[key];
|
||
if (!service) return `${label}：未连接`;
|
||
if (service.running) {
|
||
const suffix = service.port ? `（端口 ${service.port}）` : '';
|
||
return `${label}：运行中${suffix}`;
|
||
}
|
||
return `${label}：未运行${service.error ? `，${service.error}` : ''}`;
|
||
}
|
||
|
||
function buildManagedServices(snapshot: QimingclawSnapshot | null): DigitalEmployeeManagedService[] {
|
||
const fromSnapshot = snapshot?.managedServices ?? [];
|
||
if (fromSnapshot.length > 0) {
|
||
return fromSnapshot.map((service) => ({
|
||
service_id: service.serviceId,
|
||
name: service.name,
|
||
kind: service.kind,
|
||
status: service.status,
|
||
status_label: service.statusLabel,
|
||
running: service.running,
|
||
error: service.error ?? null,
|
||
requires_human_action: service.requiresHumanAction,
|
||
dependent_tasks: service.dependentTasks ?? [],
|
||
restart_count: service.restartCount ?? 0,
|
||
last_seen_at: service.lastSeenAt,
|
||
instance: service.instance,
|
||
lease: service.lease,
|
||
}));
|
||
}
|
||
|
||
return [
|
||
fallbackManagedService(snapshot, 'agent', 'Agent', 'agent', ['ACP 会话执行', 'Plan Agent']),
|
||
fallbackManagedService(snapshot, 'mcp', 'MCP Proxy', 'mcp', ['Skill Catalog', 'MCP 工具调用']),
|
||
fallbackManagedService(snapshot, 'computerServer', 'Computer Server', 'desktop', ['/computer/chat', '远程任务接入']),
|
||
fallbackManagedService(snapshot, 'fileServer', 'File Server', 'file', ['Artifact 上传', '文件交付']),
|
||
fallbackManagedService(snapshot, 'lanproxy', 'Lanproxy', 'network', ['远程访问', '管理端回连']),
|
||
fallbackManagedService(snapshot, 'guiServer', 'GUI Agent Server', 'gui', ['GUI 自动化']),
|
||
];
|
||
}
|
||
|
||
function fallbackManagedService(
|
||
snapshot: QimingclawSnapshot | null,
|
||
key: string,
|
||
name: string,
|
||
kind: string,
|
||
dependentTasks: string[],
|
||
): DigitalEmployeeManagedService {
|
||
const service = snapshot?.services[key];
|
||
const running = service?.running === true;
|
||
const status = service?.error ? 'degraded' : running ? 'running' : 'stopped';
|
||
return {
|
||
service_id: key,
|
||
name,
|
||
kind,
|
||
status,
|
||
status_label: status === 'running' ? '运行中' : status === 'degraded' ? '异常' : '未运行',
|
||
running,
|
||
error: service?.error ?? null,
|
||
requires_human_action: Boolean(service?.error),
|
||
dependent_tasks: dependentTasks,
|
||
restart_count: 0,
|
||
last_seen_at: snapshot?.generatedAt ?? new Date().toISOString(),
|
||
instance: service ? {
|
||
port: service.port,
|
||
engineType: service.engineType,
|
||
serverCount: service.serverCount,
|
||
serverNames: service.serverNames,
|
||
} : undefined,
|
||
lease: {
|
||
state: status === 'running' ? 'active' : status,
|
||
updatedAt: snapshot?.generatedAt ?? new Date().toISOString(),
|
||
},
|
||
};
|
||
}
|
||
|
||
function managedServiceLine(service: DigitalEmployeeManagedService): string {
|
||
const deps = service.dependent_tasks.length > 0 ? `；依赖任务：${service.dependent_tasks.slice(0, 2).join('、')}` : '';
|
||
return `${service.name}：${service.status_label}${service.error ? `，${service.error}` : ''}${deps}`;
|
||
}
|
||
|
||
function managedServiceSummary(services: DigitalEmployeeManagedService[]): string {
|
||
const runningCount = services.filter((service) => service.running).length;
|
||
const issueCount = services.filter((service) => service.requires_human_action || service.status === 'degraded').length;
|
||
return `ManagedService：${runningCount}/${services.length} 运行，${issueCount} 项需处理`;
|
||
}
|
||
|
||
async function handleManagedServiceRestart(
|
||
serviceId: string,
|
||
body: Record<string, unknown>,
|
||
): Promise<QimingclawManagedServiceActionResponse> {
|
||
const bridge = window.QimingClawBridge?.digital;
|
||
if (!bridge?.restartManagedService) {
|
||
const snapshot = await readQimingclawSnapshot();
|
||
return {
|
||
ok: false,
|
||
service_id: serviceId,
|
||
action: 'restart',
|
||
status: 'failed',
|
||
error: 'bridge_unavailable',
|
||
managed_service: buildManagedServices(snapshot).find((service) => service.service_id === serviceId) ?? null,
|
||
};
|
||
}
|
||
try {
|
||
const result = await bridge.restartManagedService(serviceId, {
|
||
reason: stringValue(body.reason) || 'digital_employee_managed_service_restart',
|
||
actor: stringValue(body.actor) || 'digital_employee_ui',
|
||
});
|
||
const snapshot = await readQimingclawSnapshot();
|
||
return {
|
||
...result,
|
||
managed_service: result.managed_service ?? buildManagedServices(snapshot).find((service) => service.service_id === serviceId) ?? null,
|
||
};
|
||
} catch (error) {
|
||
const snapshot = await readQimingclawSnapshot();
|
||
return {
|
||
ok: false,
|
||
service_id: serviceId,
|
||
action: 'restart',
|
||
status: 'failed',
|
||
error: error instanceof Error ? error.message : String(error),
|
||
managed_service: buildManagedServices(snapshot).find((service) => service.service_id === serviceId) ?? null,
|
||
};
|
||
}
|
||
}
|
||
|
||
async function handleArtifactAccess(
|
||
artifactId: string,
|
||
body: Record<string, unknown>,
|
||
): Promise<QimingclawArtifactAccessResponse> {
|
||
const bridge = window.QimingClawBridge?.digital;
|
||
const action = normalizeArtifactAccessAction(stringValue(body.action));
|
||
if (!bridge?.accessArtifact) {
|
||
return {
|
||
ok: false,
|
||
artifact_id: artifactId,
|
||
action,
|
||
status: 'rejected',
|
||
error: 'bridge_unavailable',
|
||
reason_codes: ['bridge_unavailable'],
|
||
};
|
||
}
|
||
try {
|
||
return await bridge.accessArtifact(artifactId, action, {
|
||
actor: stringValue(body.actor) || 'digital_employee_ui',
|
||
source: stringValue(body.source) || 'sgrobot-digital-adapter',
|
||
});
|
||
} catch (error) {
|
||
return {
|
||
ok: false,
|
||
artifact_id: artifactId,
|
||
action,
|
||
status: 'rejected',
|
||
error: error instanceof Error ? error.message : String(error),
|
||
reason_codes: ['artifact_access_failed'],
|
||
};
|
||
}
|
||
}
|
||
|
||
function normalizeArtifactAccessAction(value: string): 'preview' | 'download' | 'open_location' {
|
||
if (value === 'download' || value === 'open_location') return value;
|
||
return 'preview';
|
||
}
|
||
|
||
async function handleArtifactRetention(
|
||
artifactId: string,
|
||
body: Record<string, unknown>,
|
||
snapshot: QimingclawSnapshot | null,
|
||
): Promise<Record<string, unknown>> {
|
||
const bridge = window.QimingClawBridge?.digital;
|
||
const action = stringValue(body.action) || 'mark_review';
|
||
const artifact = artifactDetailRow(snapshot, artifactId);
|
||
if (!bridge?.recordArtifactLifecycle) {
|
||
return { ok: false, artifact_id: artifactId, action, status: 'rejected', error: 'bridge_unavailable' };
|
||
}
|
||
const result = await bridge.recordArtifactLifecycle({
|
||
artifactId,
|
||
action,
|
||
reason: stringValue(body.reason) || null,
|
||
retentionUntil: stringValue(body.retention_until ?? body.retentionUntil) || null,
|
||
versionSummary: artifact ? artifactVersionSummary(artifact) : null,
|
||
retentionSummary: artifact ? artifactRetentionSummaryForAction(artifact, action, body) : null,
|
||
deliverySummary: artifact ? artifactDeliverySummary(artifact) : null,
|
||
actor: stringValue(body.actor) || 'digital_employee_ui',
|
||
source: stringValue(body.source) || 'sgrobot-digital-adapter',
|
||
planId: artifact ? stringValue(artifact.plan_id) || null : null,
|
||
taskId: artifact ? stringValue(artifact.task_id) || null : null,
|
||
runId: artifact ? stringValue(artifact.run_id) || null : null,
|
||
});
|
||
return {
|
||
ok: Boolean(result && result.kind !== 'artifact_retention_rejected'),
|
||
artifact_id: artifactId,
|
||
action,
|
||
status: result?.kind === 'artifact_retention_rejected' ? 'rejected' : 'recorded',
|
||
event_id: result?.eventId ?? null,
|
||
item: artifact,
|
||
};
|
||
}
|
||
|
||
async function handleApprovalAction(
|
||
approvalId: string,
|
||
body: Record<string, unknown>,
|
||
snapshot: QimingclawSnapshot | null,
|
||
): Promise<Record<string, unknown>> {
|
||
const bridge = window.QimingClawBridge?.digital;
|
||
const action = stringValue(body.action) || 'comment';
|
||
const approval = approvalDetailRow(snapshot, approvalId);
|
||
if (!bridge?.recordApprovalAction) {
|
||
return { ok: false, approval_id: approvalId, action, status: 'rejected', error: 'bridge_unavailable' };
|
||
}
|
||
const result = await bridge.recordApprovalAction({
|
||
approvalId,
|
||
action,
|
||
comment: stringValue(body.comment) || null,
|
||
delegateTo: stringValue(body.delegate_to ?? body.delegateTo) || null,
|
||
delegateLabel: stringValue(body.delegate_label ?? body.delegateLabel) || null,
|
||
dueAt: stringValue(body.due_at ?? body.dueAt) || null,
|
||
riskLevel: stringValue(body.risk_level ?? body.riskLevel) || null,
|
||
reason: stringValue(body.reason) || null,
|
||
actor: stringValue(body.actor) || 'digital_employee_ui',
|
||
source: stringValue(body.source) || 'sgrobot-digital-adapter',
|
||
planId: approval ? stringValue(approval.plan_id) || null : null,
|
||
taskId: approval ? stringValue(approval.task_id) || null : null,
|
||
runId: approval ? stringValue(approval.run_id) || null : null,
|
||
});
|
||
return {
|
||
ok: Boolean(result && result.kind !== 'approval_action_rejected'),
|
||
approval_id: approvalId,
|
||
action,
|
||
status: result?.kind === 'approval_action_rejected' ? 'rejected' : 'recorded',
|
||
event_id: result?.eventId ?? null,
|
||
item: approval,
|
||
};
|
||
}
|
||
|
||
function syncLine(snapshot: QimingclawSnapshot | null): string {
|
||
const sync = snapshot?.sync;
|
||
if (!sync) return '管理端同步：未连接';
|
||
if (!sync.enabled) return '管理端同步：已停用';
|
||
if (!sync.endpoint) return '管理端同步：未配置地址';
|
||
if (sync.syncing) return `管理端同步：同步中，待同步 ${sync.pending} 条`;
|
||
if (sync.failed > 0) return `管理端同步：${sync.failed} 条失败，待同步 ${sync.pending} 条`;
|
||
if (sync.pending > 0) return `管理端同步：待同步 ${sync.pending} 条`;
|
||
return sync.lastSyncAt ? `管理端同步：已同步，最近 ${sync.lastSyncAt}` : '管理端同步：等待本地数据';
|
||
}
|
||
|
||
function compactSyncText(value?: string | null): string {
|
||
return String(value || '').replace(/\s+/g, ' ').trim();
|
||
}
|
||
|
||
function runtimePlans(snapshot: QimingclawSnapshot | null): QimingclawPlanRecord[] {
|
||
return snapshot?.runtime?.plans ?? [];
|
||
}
|
||
|
||
function runtimePlanSteps(snapshot: QimingclawSnapshot | null): QimingclawPlanStepRecord[] {
|
||
return snapshot?.runtime?.planSteps ?? [];
|
||
}
|
||
|
||
function runtimeTasks(snapshot: QimingclawSnapshot | null): QimingclawTaskRecord[] {
|
||
return snapshot?.runtime?.tasks ?? [];
|
||
}
|
||
|
||
function runtimeRuns(snapshot: QimingclawSnapshot | null): QimingclawRunRecord[] {
|
||
return snapshot?.runtime?.runs ?? [];
|
||
}
|
||
|
||
function runtimeEvents(snapshot: QimingclawSnapshot | null): QimingclawEventRecord[] {
|
||
return snapshot?.runtime?.events ?? [];
|
||
}
|
||
|
||
function runtimeArtifacts(snapshot: QimingclawSnapshot | null): QimingclawArtifactRecord[] {
|
||
return snapshot?.runtime?.artifacts ?? [];
|
||
}
|
||
|
||
function runtimeApprovals(snapshot: QimingclawSnapshot | null): QimingclawApprovalRecord[] {
|
||
return snapshot?.runtime?.approvals ?? [];
|
||
}
|
||
|
||
function hasRuntimeRecords(snapshot: QimingclawSnapshot | null): boolean {
|
||
return runtimePlans(snapshot).length > 0
|
||
|| runtimePlanSteps(snapshot).length > 0
|
||
|| runtimeTasks(snapshot).length > 0
|
||
|| runtimeArtifacts(snapshot).length > 0
|
||
|| runtimeApprovals(snapshot).length > 0;
|
||
}
|
||
|
||
function latestRuntimeTime(plan: QimingclawPlanRecord, tasks: QimingclawTaskRecord[]): string {
|
||
const sorted = [plan.updatedAt, ...tasks.map((task) => task.updatedAt)]
|
||
.filter(Boolean)
|
||
.sort();
|
||
return sorted[sorted.length - 1] ?? plan.updatedAt ?? plan.createdAt;
|
||
}
|
||
|
||
function taskStatusTone(status: string): 'running' | 'success' | 'danger' | 'waiting' {
|
||
const normalized = status.toLowerCase();
|
||
if (['completed', 'succeeded', 'success', 'done'].includes(normalized)) return 'success';
|
||
if (['failed', 'error', 'rejected', 'cancelled'].includes(normalized)) return 'danger';
|
||
if (['running', 'active', 'leased', 'syncing'].includes(normalized)) return 'running';
|
||
return 'waiting';
|
||
}
|
||
|
||
function taskStatusLabel(status: string): string {
|
||
const normalized = status.toLowerCase();
|
||
if (normalized === 'ready') return '待启动';
|
||
if (normalized === 'blocked') return '依赖阻塞';
|
||
if (normalized === 'skipped') return '已跳过';
|
||
if (normalized === 'cancelled') return '已取消';
|
||
if (normalized === 'paused') return '已暂停';
|
||
const tone = taskStatusTone(status);
|
||
if (tone === 'success') return '已完成';
|
||
if (tone === 'danger') return '异常';
|
||
if (tone === 'running') return '执行中';
|
||
return '待执行';
|
||
}
|
||
|
||
function runtimePlanTasks(snapshot: QimingclawSnapshot | null, planId: string): QimingclawTaskRecord[] {
|
||
return runtimeTasks(snapshot).filter((task) => task.planId === planId);
|
||
}
|
||
|
||
function runtimeStepsForPlan(snapshot: QimingclawSnapshot | null, planId: string): QimingclawPlanStepRecord[] {
|
||
return runtimePlanSteps(snapshot)
|
||
.filter((step) => step.planId === planId)
|
||
.sort((left, right) => left.seq - right.seq || left.createdAt.localeCompare(right.createdAt));
|
||
}
|
||
|
||
function taskStepId(task: QimingclawTaskRecord): string {
|
||
const record = asRecord(task.payload);
|
||
return stringValue(record?.stepId ?? record?.step_id) || (task.planId ? `${task.planId}:runtime` : 'qimingclaw-runtime');
|
||
}
|
||
|
||
function planRecordStatus(plan: QimingclawPlanRecord, tasks: QimingclawTaskRecord[]): string {
|
||
if (tasks.some((task) => taskStatusTone(task.status) === 'danger')) return 'failed';
|
||
if (tasks.some((task) => taskStatusTone(task.status) === 'running')) return 'running';
|
||
if (tasks.length > 0 && tasks.every((task) => taskStatusTone(task.status) === 'success')) return 'completed';
|
||
return plan.status || 'pending';
|
||
}
|
||
|
||
function buildPlanAgents(snapshot: QimingclawSnapshot | null): DigitalEmployeePlanAgentState[] {
|
||
return runtimePlans(snapshot).map((plan) => {
|
||
const tasks = runtimePlanTasks(snapshot, plan.id);
|
||
const status = planRecordStatus(plan, tasks);
|
||
const tone = planStatusTone(status);
|
||
const failedTaskCount = tasks.filter((task) => taskStatusTone(task.status) === 'danger').length;
|
||
const runningTaskCount = tasks.filter((task) => taskStatusTone(task.status) === 'running').length;
|
||
return {
|
||
agent_id: `plan-agent-${slugifyIdPart(plan.id)}`,
|
||
plan_id: plan.id,
|
||
title: plan.title,
|
||
lifecycle: status,
|
||
status_label: planStatusLabel(status),
|
||
status_tone: tone,
|
||
managed_task_count: tasks.length,
|
||
running_task_count: runningTaskCount,
|
||
failed_task_count: failedTaskCount,
|
||
next_action: failedTaskCount > 0 ? 'review_failures' : runningTaskCount > 0 ? 'monitor_runs' : tone === 'success' ? 'archive_results' : 'activate_plan',
|
||
can_replan: failedTaskCount > 0,
|
||
can_pause: runningTaskCount > 0,
|
||
can_resume: status === 'paused',
|
||
updated_at: latestRuntimeTime(plan, tasks),
|
||
};
|
||
});
|
||
}
|
||
|
||
function buildTaskAgents(snapshot: QimingclawSnapshot | null): DigitalEmployeeTaskAgentState[] {
|
||
const runs = runtimeRuns(snapshot);
|
||
return runtimeTasks(snapshot).map((task) => {
|
||
const latestRun = latestRunForTask(runs, task.id);
|
||
const tone = taskStatusTone(task.status);
|
||
const normalizedStatus = task.status.toLowerCase();
|
||
const stepId = taskStepId(task);
|
||
return {
|
||
agent_id: `task-agent-${slugifyIdPart(task.id)}`,
|
||
task_id: task.id,
|
||
plan_id: task.planId ?? null,
|
||
step_id: stepId,
|
||
title: task.title,
|
||
execution_state: task.status,
|
||
status_label: taskStatusLabel(task.status),
|
||
status_tone: tone,
|
||
assigned_skill_id: task.assignedSkillId ?? null,
|
||
latest_run_id: latestRun?.id ?? null,
|
||
can_retry: ['failed', 'cancelled', 'skipped'].includes(normalizedStatus),
|
||
can_skip: ['pending', 'running'].includes(normalizedStatus),
|
||
can_cancel: ['pending', 'running', 'paused'].includes(normalizedStatus),
|
||
next_action: taskAgentNextAction(normalizedStatus, tone),
|
||
updated_at: latestRun?.updatedAt ?? task.updatedAt,
|
||
};
|
||
});
|
||
}
|
||
|
||
function taskAgentNextAction(
|
||
status: string,
|
||
tone: ReturnType<typeof taskStatusTone>,
|
||
): string {
|
||
if (['failed', 'cancelled', 'skipped'].includes(status)) return 'retry_or_review';
|
||
if (status === 'paused') return 'resume_or_cancel';
|
||
if (tone === 'running') return 'watch_progress';
|
||
if (tone === 'success') return 'collect_artifacts';
|
||
return 'start_run';
|
||
}
|
||
|
||
function latestRunForTask(runs: QimingclawRunRecord[], taskId: string): QimingclawRunRecord | null {
|
||
const sorted = runs
|
||
.filter((run) => run.taskId === taskId)
|
||
.sort((left, right) => (right.updatedAt || right.createdAt).localeCompare(left.updatedAt || left.createdAt));
|
||
return sorted[0] ?? null;
|
||
}
|
||
|
||
function runtimePlanToDebugPlan(plan: QimingclawPlanRecord, snapshot: QimingclawSnapshot | null): DebugPlan {
|
||
const tasks = runtimePlanTasks(snapshot, plan.id);
|
||
const planSteps = runtimeStepsForPlan(snapshot, plan.id);
|
||
const status = planRecordStatus(plan, tasks);
|
||
const knownStepIds = new Set(planSteps.map((step) => step.id));
|
||
const orphanTasks = tasks.filter((task) => !knownStepIds.has(taskStepId(task)));
|
||
const steps = planSteps.length > 0
|
||
? [
|
||
...planSteps.map((step) => runtimePlanStepToSummary(step, tasks)),
|
||
...(orphanTasks.length > 0 ? [runtimeFallbackStepToSummary(plan.id, orphanTasks)] : []),
|
||
]
|
||
: [runtimeFallbackStepToSummary(plan.id, tasks)];
|
||
return {
|
||
plan_id: plan.id,
|
||
title: plan.title,
|
||
objective: plan.objective ?? undefined,
|
||
status,
|
||
created_at: plan.createdAt,
|
||
updated_at: latestRuntimeTime(plan, tasks),
|
||
source: plan.source,
|
||
sync_status: plan.syncStatus,
|
||
steps,
|
||
};
|
||
}
|
||
|
||
function runtimePlanStepToSummary(
|
||
step: QimingclawPlanStepRecord,
|
||
tasks: QimingclawTaskRecord[],
|
||
): PlanStepSummary {
|
||
return {
|
||
step_id: step.id,
|
||
title: step.title,
|
||
depends_on: step.dependsOn,
|
||
preferred_skills: step.preferredSkillIds,
|
||
tasks: tasks
|
||
.filter((task) => taskStepId(task) === step.id)
|
||
.map((task) => ({
|
||
task_id: task.id,
|
||
title: task.title,
|
||
status: task.status,
|
||
})),
|
||
};
|
||
}
|
||
|
||
function runtimeFallbackStepToSummary(
|
||
planId: string,
|
||
tasks: QimingclawTaskRecord[],
|
||
): PlanStepSummary {
|
||
return {
|
||
step_id: `${planId}:runtime`,
|
||
title: 'qimingclaw 执行记录',
|
||
depends_on: [],
|
||
preferred_skills: [...new Set(tasks.map((task) => task.assignedSkillId).filter((value): value is string => Boolean(value)))],
|
||
tasks: tasks.map((task) => ({
|
||
task_id: task.id,
|
||
title: task.title,
|
||
status: task.status,
|
||
})),
|
||
};
|
||
}
|
||
|
||
function runtimeTaskToDebugTask(task: QimingclawTaskRecord): DebugTask {
|
||
return {
|
||
task_id: task.id,
|
||
title: task.title,
|
||
status: task.status,
|
||
plan_id: task.planId ?? null,
|
||
step_id: taskStepId(task),
|
||
assigned_skill_id: task.assignedSkillId ?? '',
|
||
description: task.syncError ?? '',
|
||
created_at: task.createdAt,
|
||
updated_at: task.updatedAt,
|
||
started_at: task.createdAt,
|
||
finished_at: taskStatusTone(task.status) === 'success' || taskStatusTone(task.status) === 'danger'
|
||
? task.updatedAt
|
||
: null,
|
||
error_message: task.syncError ?? null,
|
||
sync_status: task.syncStatus,
|
||
};
|
||
}
|
||
|
||
function runtimeRunToDebugRun(run: QimingclawRunRecord, events: QimingclawEventRecord[]): DebugRun {
|
||
return {
|
||
run_id: run.id,
|
||
task_id: run.taskId ?? '',
|
||
plan_id: run.planId ?? null,
|
||
skill_id: undefined,
|
||
attempt_no: 1,
|
||
lifecycle: taskStatusTone(run.status) === 'success'
|
||
? 'Succeeded'
|
||
: taskStatusTone(run.status) === 'danger'
|
||
? 'Failed'
|
||
: taskStatusTone(run.status) === 'running'
|
||
? 'Running'
|
||
: run.status,
|
||
created_at: run.startedAt ?? run.createdAt,
|
||
completed_at: run.finishedAt ?? null,
|
||
events: events.filter((event) => event.runId === run.id).map((event) => ({
|
||
event_id: event.id,
|
||
kind: event.kind,
|
||
occurred_at: event.occurredAt,
|
||
message: event.message,
|
||
})),
|
||
artifacts: artifactsForRun(run, events),
|
||
sync_status: run.syncStatus,
|
||
};
|
||
}
|
||
|
||
function syncFailureLine(failure: QimingclawSyncFailure): string {
|
||
const error = compactSyncText(failure.error);
|
||
const detail = error.length > 120 ? `${error.slice(0, 120)}...` : error;
|
||
const retryText = failure.dueForRetry
|
||
? '等待补偿'
|
||
: failure.nextRetryAt
|
||
? `下次重试 ${failure.nextRetryAt}`
|
||
: '等待重试';
|
||
return `${failure.entityType}/${failure.operation} ${failure.id} 重试 ${failure.attempts} 次，${retryText}${detail ? `，${detail}` : ''}`;
|
||
}
|
||
|
||
function withRuntimePlan(plan: DebugPlan, snapshot: QimingclawSnapshot | null): DebugPlan {
|
||
return { ...plan, status: runtimeStatusForPlan(plan, snapshot) };
|
||
}
|
||
|
||
function planStatusLabel(status: string): string {
|
||
if (status === 'running') return '执行中';
|
||
if (status === 'completed' || status === 'succeeded') return '已完成';
|
||
if (status === 'failed') return '异常';
|
||
return '待执行';
|
||
}
|
||
|
||
function runtimeDebugPlans(snapshot: QimingclawSnapshot | null): DebugPlan[] {
|
||
const plans = runtimePlans(snapshot);
|
||
if (plans.length > 0) return plans.map((plan) => runtimePlanToDebugPlan(plan, snapshot));
|
||
const tasks = runtimeTasks(snapshot);
|
||
if (tasks.length === 0) return [];
|
||
return tasks.map((task) => ({
|
||
plan_id: task.id,
|
||
title: task.title,
|
||
objective: '未绑定 Plan 的 qimingclaw 本地任务记录。',
|
||
status: task.status,
|
||
created_at: task.createdAt,
|
||
updated_at: task.updatedAt,
|
||
source: 'qimingclaw',
|
||
sync_status: task.syncStatus,
|
||
steps: [
|
||
{
|
||
step_id: `${task.id}:runtime`,
|
||
title: 'qimingclaw 执行记录',
|
||
depends_on: [],
|
||
preferred_skills: task.assignedSkillId ? [task.assignedSkillId] : [],
|
||
tasks: [{ task_id: task.id, title: task.title, status: task.status }],
|
||
},
|
||
],
|
||
}));
|
||
}
|
||
|
||
function templatePlans(snapshot: QimingclawSnapshot | null): DebugPlan[] {
|
||
const customTemplates = snapshot?.planTemplates ?? [];
|
||
const byId = new Map<string, DebugPlan>();
|
||
for (const plan of [...customTemplates, ...PLANS]) {
|
||
if (!byId.has(plan.plan_id)) byId.set(plan.plan_id, plan);
|
||
}
|
||
return Array.from(byId.values());
|
||
}
|
||
|
||
function mergedDebugPlans(snapshot: QimingclawSnapshot | null): DebugPlan[] {
|
||
const byId = new Map<string, DebugPlan>();
|
||
for (const plan of [...runtimeDebugPlans(snapshot), ...templatePlans(snapshot).map((plan) => withRuntimePlan(plan, snapshot))]) {
|
||
if (!byId.has(plan.plan_id)) byId.set(plan.plan_id, plan);
|
||
}
|
||
return Array.from(byId.values());
|
||
}
|
||
|
||
function planTemplateJob(plan: DebugPlan, snapshot: QimingclawSnapshot | null): CronJob {
|
||
const normalizedPlan = withRuntimePlan(plan, snapshot);
|
||
const schedule = PLAN_SCHEDULES[plan.plan_id] ?? PLAN_SCHEDULES['qimingclaw-client-readiness']!;
|
||
return {
|
||
id: `schedule-${plan.plan_id}`,
|
||
name: plan.title,
|
||
expression: schedule.expression,
|
||
command: `digital-employee:${plan.plan_id}`,
|
||
prompt: plan.objective ?? null,
|
||
job_type: 'plan_template',
|
||
schedule: { expression: schedule.expression, template_id: plan.plan_id },
|
||
enabled: true,
|
||
delivery: { mode: 'plan_template', template_id: plan.plan_id },
|
||
template_id: plan.plan_id,
|
||
trigger_kind: 'scheduled',
|
||
step_count: plan.steps?.length ?? 0,
|
||
skill_ids: [...new Set((plan.steps ?? []).flatMap((step) => step.preferred_skills ?? []))],
|
||
delete_after_run: false,
|
||
created_at: plan.created_at,
|
||
next_run: schedule.nextRun,
|
||
last_run: normalizedPlan.status === 'running' ? todayAt(9, 5) : null,
|
||
last_status: normalizedPlan.status === 'running' ? 'running' : null,
|
||
last_output: null,
|
||
};
|
||
}
|
||
|
||
function runtimeScheduleJob(schedule: QimingclawScheduleRecord, snapshot: QimingclawSnapshot | null): CronJob {
|
||
const plan = schedule.planId
|
||
? mergedDebugPlans(snapshot).find((item) => item.plan_id === schedule.planId)
|
||
: null;
|
||
const runs = snapshot?.runtime?.scheduleRuns ?? [];
|
||
const latestRun = runs.find((run) => run.scheduleId === schedule.id);
|
||
return {
|
||
id: schedule.id,
|
||
name: schedule.name,
|
||
expression: schedule.cronExpr,
|
||
command: schedule.command || `digital-employee:${schedule.planId || schedule.id}`,
|
||
prompt: schedule.prompt ?? schedule.description ?? null,
|
||
job_type: 'qimingclaw_schedule',
|
||
schedule: {
|
||
mode: 'qimingclaw_schedule',
|
||
schedule_id: schedule.id,
|
||
plan_id: schedule.planId,
|
||
expression: schedule.cronExpr,
|
||
timezone: schedule.timezone,
|
||
status: schedule.status,
|
||
failure_count: schedule.failureCount,
|
||
last_error: schedule.lastError,
|
||
},
|
||
enabled: schedule.enabled && schedule.status === 'enabled' && !schedule.deletedAt,
|
||
delivery: { mode: 'qimingclaw_schedule', schedule_id: schedule.id, plan_id: schedule.planId },
|
||
template_id: schedule.planId ?? schedule.id,
|
||
trigger_kind: 'scheduled',
|
||
step_count: plan?.steps?.length ?? 0,
|
||
skill_ids: [...new Set((plan?.steps ?? []).flatMap((step) => step.preferred_skills ?? []))],
|
||
delete_after_run: false,
|
||
created_at: schedule.createdAt,
|
||
next_run: schedule.nextRunAt || schedule.updatedAt,
|
||
last_run: schedule.lastRunAt ?? latestRun?.finishedAt ?? latestRun?.startedAt ?? null,
|
||
last_status: latestRun?.status ?? (schedule.lastError ? 'failed' : null),
|
||
last_output: latestRun?.error ?? schedule.lastError ?? null,
|
||
};
|
||
}
|
||
|
||
function buildSchedulerJobs(snapshot: QimingclawSnapshot | null = null): CronJob[] {
|
||
const realScheduleJobs = (snapshot?.runtime?.schedules ?? [])
|
||
.filter((schedule) => schedule.status !== 'deleted')
|
||
.map((schedule) => runtimeScheduleJob(schedule, snapshot));
|
||
const templateJobs = templatePlans(snapshot).map((plan) => planTemplateJob(plan, snapshot));
|
||
if (realScheduleJobs.length > 0) {
|
||
const realTemplateIds = new Set<string | null | undefined>(realScheduleJobs.map((job) => job.template_id));
|
||
return [
|
||
...realScheduleJobs,
|
||
...templateJobs.filter((job) => !realTemplateIds.has(job.template_id)),
|
||
];
|
||
}
|
||
if (hasRuntimeRecords(snapshot)) {
|
||
const runtimeJobs = runtimeDebugPlans(snapshot).map((plan) => ({
|
||
id: `runtime-${plan.plan_id}`,
|
||
name: plan.title,
|
||
expression: '',
|
||
command: `qimingclaw-runtime:${plan.plan_id}`,
|
||
prompt: plan.objective ?? null,
|
||
job_type: 'qimingclaw_runtime',
|
||
schedule: { mode: 'runtime_record', plan_id: plan.plan_id },
|
||
enabled: true,
|
||
delivery: { mode: 'qimingclaw_runtime', plan_id: plan.plan_id },
|
||
template_id: plan.plan_id,
|
||
trigger_kind: 'runtime_record',
|
||
step_count: plan.steps?.length ?? 0,
|
||
skill_ids: [...new Set((plan.steps ?? []).flatMap((step) => step.preferred_skills ?? []))],
|
||
delete_after_run: false,
|
||
created_at: plan.created_at,
|
||
next_run: plan.updated_at ?? plan.created_at,
|
||
last_run: plan.updated_at ?? plan.created_at,
|
||
last_status: plan.status,
|
||
last_output: null,
|
||
}));
|
||
const runtimeIds = new Set<string | null | undefined>(runtimeJobs.map((job) => job.template_id));
|
||
return [
|
||
...runtimeJobs,
|
||
...templateJobs.filter((job) => !runtimeIds.has(job.template_id)),
|
||
];
|
||
}
|
||
return templateJobs;
|
||
}
|
||
|
||
function buildDuties(state: AdapterState, date: string, snapshot: QimingclawSnapshot | null): DigitalEmployeeDuty[] {
|
||
const selected = selectedSetForDate(state, date);
|
||
if (hasRuntimeRecords(snapshot)) {
|
||
const plans = runtimePlans(snapshot);
|
||
const tasksWithoutPlan = runtimeTasks(snapshot).filter((task) => !task.planId);
|
||
const planDuties = plans.map((plan, index) => {
|
||
const tasks = runtimePlanTasks(snapshot, plan.id);
|
||
const status = planRecordStatus(plan, tasks);
|
||
const successCount = tasks.filter((task) => taskStatusTone(task.status) === 'success').length;
|
||
const failureCount = tasks.filter((task) => taskStatusTone(task.status) === 'danger').length;
|
||
const selectedByDefault = selected.size === 0 ? index < 3 : selected.has(plan.id);
|
||
return {
|
||
id: plan.id,
|
||
title: plan.title,
|
||
summary: plan.objective || 'qimingclaw 本地执行记录已同步到数字员工。',
|
||
implemented: true,
|
||
selectable: true,
|
||
selected: selectedByDefault,
|
||
status,
|
||
status_label: taskStatusLabel(status),
|
||
status_tone: taskStatusTone(status),
|
||
schedule_text: tasks.length > 0 ? `最近更新 ${formatTime(latestRuntimeTime(plan, tasks))}` : '等待任务记录',
|
||
result_text: tasks.length > 0
|
||
? `${tasks.length} 项任务，${successCount} 项完成，${failureCount} 项异常`
|
||
: `同步状态：${plan.syncStatus}`,
|
||
conversation_id: plan.id,
|
||
};
|
||
});
|
||
const standaloneDuties = tasksWithoutPlan.map((task, index) => ({
|
||
id: task.id,
|
||
title: task.title,
|
||
summary: '未绑定 Plan 的 qimingclaw 本地任务记录。',
|
||
implemented: true,
|
||
selectable: true,
|
||
selected: selected.size === 0 ? planDuties.length + index < 3 : selected.has(task.id),
|
||
status: task.status,
|
||
status_label: taskStatusLabel(task.status),
|
||
status_tone: taskStatusTone(task.status),
|
||
schedule_text: `最近更新 ${formatTime(task.updatedAt)}`,
|
||
result_text: task.syncError || `同步状态：${task.syncStatus}`,
|
||
conversation_id: task.id,
|
||
}));
|
||
const runtimeDutyIds = new Set([...planDuties, ...standaloneDuties].map((duty) => duty.id));
|
||
return [
|
||
...planDuties,
|
||
...standaloneDuties,
|
||
...templateDuties(state, date, snapshot).filter((duty) => !runtimeDutyIds.has(duty.id)),
|
||
];
|
||
}
|
||
return templateDuties(state, date, snapshot);
|
||
}
|
||
|
||
function templateDuties(
|
||
state: AdapterState,
|
||
date: string,
|
||
snapshot: QimingclawSnapshot | null,
|
||
): DigitalEmployeeDuty[] {
|
||
const selected = selectedSetForDate(state, date);
|
||
return templatePlans(snapshot).map((rawPlan) => {
|
||
const plan = withRuntimePlan(rawPlan, snapshot);
|
||
const schedule = PLAN_SCHEDULES[plan.plan_id] ?? PLAN_SCHEDULES['qimingclaw-client-readiness']!;
|
||
return {
|
||
id: plan.plan_id,
|
||
title: plan.title,
|
||
summary: plan.objective ?? '等待 qimingclaw 执行链路补充任务说明。',
|
||
implemented: true,
|
||
selectable: true,
|
||
selected: selected.has(plan.plan_id),
|
||
status: plan.status,
|
||
status_label: planStatusLabel(plan.status),
|
||
status_tone: planStatusTone(plan.status),
|
||
schedule_text: schedule.scheduleText,
|
||
result_text: planResultText(plan, snapshot),
|
||
conversation_id: plan.plan_id,
|
||
};
|
||
});
|
||
}
|
||
|
||
function planResultText(plan: DebugPlan, snapshot: QimingclawSnapshot | null): string {
|
||
if (plan.plan_id === 'qimingclaw-client-readiness') {
|
||
return [
|
||
serviceLine(snapshot, 'agent', 'Agent'),
|
||
serviceLine(snapshot, 'mcp', 'MCP'),
|
||
`活跃会话：${snapshot?.sessions.active ?? 0}`,
|
||
].join('；');
|
||
}
|
||
if (plan.plan_id === 'qimingclaw-remote-task-ingress') {
|
||
return [
|
||
serviceLine(snapshot, 'computerServer', 'Computer Server'),
|
||
serviceLine(snapshot, 'lanproxy', 'Lanproxy'),
|
||
serviceLine(snapshot, 'fileServer', 'File Server'),
|
||
].join('；');
|
||
}
|
||
return plan.status === 'running' ? '正在同步客户端运行状态' : '等待任务执行';
|
||
}
|
||
|
||
function buildTasks(planId?: string | null, snapshot: QimingclawSnapshot | null = null): DebugTask[] {
|
||
const templateTasks = templatePlans(snapshot)
|
||
.filter((plan) => !planId || plan.plan_id === planId)
|
||
.map((plan) => withRuntimePlan(plan, snapshot))
|
||
.flatMap(templatePlanTasks);
|
||
if (hasRuntimeRecords(snapshot)) {
|
||
const runtimeResult = runtimeTasks(snapshot)
|
||
.filter((task) => !planId || task.planId === planId || task.id === planId)
|
||
.map(runtimeTaskToDebugTask);
|
||
const runtimeTaskIds = new Set(runtimeResult.map((task) => task.task_id));
|
||
return [
|
||
...runtimeResult,
|
||
...templateTasks.filter((task) => !runtimeTaskIds.has(task.task_id)),
|
||
];
|
||
}
|
||
return templateTasks;
|
||
}
|
||
|
||
function templatePlanTasks(plan: DebugPlan): DebugTask[] {
|
||
return (plan.steps ?? []).flatMap((step) => (step.tasks ?? []).map((task) => ({
|
||
task_id: task.task_id,
|
||
title: task.title,
|
||
status: plan.status === 'running' && task.status === 'pending' ? 'running' : task.status,
|
||
plan_id: plan.plan_id,
|
||
step_id: step.step_id,
|
||
assigned_skill_id: step.preferred_skills?.[0] ?? '',
|
||
description: `${plan.title} · ${step.title}`,
|
||
created_at: plan.created_at,
|
||
updated_at: plan.status === 'running' ? new Date().toISOString() : plan.created_at,
|
||
started_at: task.status === 'running' ? todayAt(9, 5) : null,
|
||
finished_at: task.status === 'completed' ? todayAt(9, 10) : null,
|
||
})));
|
||
}
|
||
|
||
function buildRuns(tasks: DebugTask[]): DebugRun[] {
|
||
return tasks
|
||
.filter((task) => task.status === 'running' || task.status === 'completed')
|
||
.map((task, index) => ({
|
||
run_id: `qimingclaw-run-${index + 1}`,
|
||
task_id: task.task_id,
|
||
plan_id: task.plan_id,
|
||
skill_id: task.assigned_skill_id,
|
||
attempt_no: 1,
|
||
lifecycle: task.status === 'running' ? 'Running' : 'Succeeded',
|
||
created_at: task.started_at ?? task.created_at,
|
||
completed_at: task.finished_at,
|
||
events: [
|
||
{
|
||
event_id: `${task.task_id}-event-start`,
|
||
kind: 'RunStarted',
|
||
occurred_at: task.started_at ?? task.created_at,
|
||
message: `${task.title} 已进入 qimingclaw 执行链路`,
|
||
},
|
||
],
|
||
}));
|
||
}
|
||
|
||
function buildTasksResponse(planId?: string | null, snapshot: QimingclawSnapshot | null = null): { tasks: DebugTask[]; runs: DebugRun[]; total: number; truncated: boolean } {
|
||
const tasks = buildTasks(planId, snapshot);
|
||
if (hasRuntimeRecords(snapshot)) {
|
||
const taskIds = new Set(tasks.map((task) => task.task_id));
|
||
const runs = runtimeRuns(snapshot)
|
||
.filter((run) => !run.taskId || taskIds.has(run.taskId))
|
||
.map((run) => runtimeRunToDebugRun(run, runtimeEvents(snapshot)));
|
||
return { tasks, runs, total: tasks.length, truncated: false };
|
||
}
|
||
return { tasks, runs: buildRuns(tasks), total: tasks.length, truncated: false };
|
||
}
|
||
|
||
function buildDebugStore(snapshot: QimingclawSnapshot | null): DebugStoreResponse {
|
||
const plans = filterPlans(null, snapshot);
|
||
const tasks = buildTasks(null, snapshot);
|
||
const runs = buildTasksResponse(null, snapshot).runs;
|
||
const realPlanSteps = runtimePlanSteps(snapshot);
|
||
return {
|
||
tables: {
|
||
canonical_events: buildCanonicalEvents(snapshot, tasks, runs),
|
||
tasks,
|
||
runs,
|
||
plans,
|
||
plan_steps: realPlanSteps.length > 0
|
||
? realPlanSteps.map((step) => runtimePlanStepToSummary(step, runtimeTasks(snapshot)))
|
||
: plans.flatMap((plan) => plan.steps ?? []),
|
||
approvals: buildApprovals(snapshot),
|
||
artifacts: buildArtifacts(snapshot),
|
||
},
|
||
};
|
||
}
|
||
|
||
function buildDashboard(snapshot: QimingclawSnapshot | null): DashboardResponse {
|
||
const tasks = buildTasks(null, snapshot);
|
||
const queued = tasks.filter((task) => taskStatusTone(task.status) === 'waiting').length;
|
||
const running = tasks.filter((task) => taskStatusTone(task.status) === 'running').length;
|
||
const succeeded = tasks.filter((task) => taskStatusTone(task.status) === 'success').length;
|
||
const failed = tasks.filter((task) => taskStatusTone(task.status) === 'danger').length;
|
||
const approvals = buildApprovals(snapshot);
|
||
return {
|
||
runtime: {
|
||
active_tasks: running,
|
||
failed_tasks: failed,
|
||
pending_confirmations: approvals.filter((approval) => approval.status === 'pending').length,
|
||
},
|
||
tasks: {
|
||
total: tasks.length,
|
||
queued,
|
||
running,
|
||
succeeded,
|
||
failed,
|
||
},
|
||
approvals: {
|
||
total: approvals.length,
|
||
pending: approvals.filter((approval) => approval.status === 'pending').length,
|
||
},
|
||
};
|
||
}
|
||
|
||
function buildDoctor(snapshot: QimingclawSnapshot | null): { results: DiagResult[]; summary: Record<string, unknown> } {
|
||
const now = new Date().toISOString();
|
||
const managedServices = buildManagedServices(snapshot);
|
||
const tasks = buildTasks(null, snapshot);
|
||
const approvals = buildApprovals(snapshot);
|
||
const runtimeErrors = runtimeEvents(snapshot).filter((event) => /fail|error|reject|cancel/i.test(`${event.kind} ${event.message}`));
|
||
const results: DiagResult[] = managedServices.map((service) => ({
|
||
id: `service:${service.service_id}`,
|
||
severity: service.requires_human_action || service.status === 'stopped' ? 'error' : service.status === 'degraded' ? 'warn' : 'ok',
|
||
category: 'service',
|
||
message: `${service.name}：${service.status_label || service.status}`,
|
||
details: compactRecord({ error: service.error, kind: service.kind, running: service.running, dependent_tasks: service.dependent_tasks }),
|
||
source: 'qimingclaw-managed-service',
|
||
created_at: service.last_seen_at || now,
|
||
}));
|
||
|
||
const sync = snapshot?.sync;
|
||
results.push({
|
||
id: 'sync:management',
|
||
severity: doctorSeverityForSync(sync ?? null),
|
||
category: 'sync',
|
||
message: syncLine(snapshot),
|
||
details: sync ? compactRecord({ pending: sync.pending, failed: sync.failed, endpoint: sync.endpoint, missing_credentials: sync.missingCredentials, last_error: sync.lastSyncError }) : null,
|
||
source: 'qimingclaw-sync-status',
|
||
created_at: sync?.lastSyncAt ?? now,
|
||
});
|
||
|
||
for (const failure of sync?.recentFailures ?? []) {
|
||
results.push({
|
||
id: `sync_failure:${failure.id}`,
|
||
severity: failure.dueForRetry === false ? 'error' : 'warn',
|
||
category: 'sync',
|
||
message: syncFailureLine(failure),
|
||
details: compactRecord({ entity_type: failure.entityType, entity_id: failure.entityId, operation: failure.operation, attempts: failure.attempts, next_retry_at: failure.nextRetryAt }),
|
||
source: 'qimingclaw-sync-failure',
|
||
created_at: failure.lastAttemptAt ?? failure.updatedAt ?? failure.createdAt,
|
||
});
|
||
}
|
||
|
||
const failedTasks = tasks.filter((task) => taskStatusTone(task.status) === 'danger');
|
||
results.push({
|
||
id: 'runtime:tasks',
|
||
severity: failedTasks.length > 0 ? 'error' : tasks.length === 0 ? 'warn' : 'ok',
|
||
category: 'runtime',
|
||
message: tasks.length === 0 ? '尚未读取到 qimingclaw runtime task。' : `任务 ${tasks.length} 个，异常 ${failedTasks.length} 个。`,
|
||
details: compactRecord({ task_count: tasks.length, failed_task_count: failedTasks.length }),
|
||
source: 'qimingclaw-runtime-records',
|
||
created_at: now,
|
||
});
|
||
results.push({
|
||
id: 'runtime:approvals',
|
||
severity: approvals.some((approval) => approval.status === 'pending') ? 'warn' : 'ok',
|
||
category: 'approval',
|
||
message: `审批 ${approvals.length} 个，待处理 ${approvals.filter((approval) => approval.status === 'pending').length} 个。`,
|
||
details: compactRecord({ approval_count: approvals.length, pending_count: approvals.filter((approval) => approval.status === 'pending').length }),
|
||
source: 'qimingclaw-approval-records',
|
||
created_at: now,
|
||
});
|
||
if (runtimeErrors.length > 0) {
|
||
results.push({
|
||
id: 'runtime:events:error',
|
||
severity: 'error',
|
||
category: 'runtime',
|
||
message: `最近运行事件中发现 ${runtimeErrors.length} 条异常事实。`,
|
||
details: { event_ids: runtimeErrors.slice(0, 8).map((event) => event.id) },
|
||
source: 'qimingclaw-runtime-events',
|
||
created_at: runtimeErrors[0]?.occurredAt ?? now,
|
||
});
|
||
}
|
||
if (!hasRuntimeRecords(snapshot)) {
|
||
results.push({
|
||
id: 'runtime:data:empty',
|
||
severity: 'warn',
|
||
category: 'data',
|
||
message: '本地数字员工 runtime 记录为空，页面将只显示兼容投影。',
|
||
source: 'qimingclaw-runtime-records',
|
||
created_at: now,
|
||
});
|
||
}
|
||
|
||
return {
|
||
results,
|
||
summary: {
|
||
ok: results.filter((result) => result.severity === 'ok').length,
|
||
warn: results.filter((result) => result.severity === 'warn').length,
|
||
error: results.filter((result) => result.severity === 'error').length,
|
||
generated_at: now,
|
||
source: 'qimingclaw-runtime-projection',
|
||
},
|
||
};
|
||
}
|
||
|
||
function doctorSeverityForSync(sync: QimingclawSyncStatus | null): DiagResult['severity'] {
|
||
if (!sync) return 'warn';
|
||
if (sync.failed > 0 || sync.lastSyncError || (sync.missingCredentials?.length ?? 0) > 0) return 'error';
|
||
if (!sync.enabled || !sync.endpoint || sync.pending > 0) return 'warn';
|
||
return 'ok';
|
||
}
|
||
|
||
function buildCostSummary(snapshot: QimingclawSnapshot | null): CostSummary {
|
||
const requestCount = runtimeEvents(snapshot).length + runtimeRuns(snapshot).length + runtimeTasks(snapshot).length;
|
||
return {
|
||
session_cost_usd: 0,
|
||
daily_cost_usd: 0,
|
||
monthly_cost_usd: 0,
|
||
total_tokens: 0,
|
||
request_count: requestCount,
|
||
by_model: {
|
||
'qimingclaw-local': {
|
||
model: 'qimingclaw-local',
|
||
cost_usd: 0,
|
||
total_tokens: 0,
|
||
request_count: requestCount,
|
||
},
|
||
},
|
||
estimated: true,
|
||
source: 'qimingclaw-runtime-projection',
|
||
updated_at: snapshot?.generatedAt ?? new Date().toISOString(),
|
||
};
|
||
}
|
||
|
||
function buildAuditEvents(snapshot: QimingclawSnapshot | null, searchParams: URLSearchParams): Array<Record<string, unknown>> {
|
||
const limit = Math.max(1, Math.min(Math.floor(numberValue(searchParams.get('limit')) ?? 100), 300));
|
||
const category = stringValue(searchParams.get('category')) || stringValue(searchParams.get('kind'));
|
||
const level = stringValue(searchParams.get('level'));
|
||
const entityId = stringValue(searchParams.get('id'));
|
||
const events = [
|
||
...runtimeEvents(snapshot).map(auditEventFromRuntimeEvent),
|
||
...(snapshot?.sync?.recentFailures ?? []).map((failure) => ({
|
||
audit_id: `sync_failure:${failure.id}`,
|
||
category: 'sync',
|
||
action: 'sync_failed',
|
||
level: failure.dueForRetry === false ? 'error' : 'warn',
|
||
message: syncFailureLine(failure),
|
||
actor: 'qimingclaw-sync',
|
||
entity_type: failure.entityType,
|
||
entity_id: failure.entityId,
|
||
occurred_at: failure.lastAttemptAt ?? failure.updatedAt ?? failure.createdAt,
|
||
payload: failure,
|
||
})),
|
||
...buildArtifacts(snapshot).flatMap((artifact) => auditEventsFromArtifact(artifact)),
|
||
];
|
||
return events
|
||
.filter((event) => !category || stringValue(event.category) === category || stringValue(event.entity_type) === category)
|
||
.filter((event) => !level || stringValue(event.level) === level)
|
||
.filter((event) => !entityId || stringValue(event.entity_id) === entityId || stringValue(event.audit_id).includes(entityId))
|
||
.sort((left, right) => stringValue(right.occurred_at).localeCompare(stringValue(left.occurred_at)))
|
||
.slice(0, limit);
|
||
}
|
||
|
||
function buildDiagnosticSummary(snapshot: QimingclawSnapshot | null): DigitalEmployeeDiagnosticSummary {
|
||
const doctorResults = buildDoctor(snapshot).results;
|
||
const auditEvents = buildAuditEvents(snapshot, new URLSearchParams({ limit: '300' }));
|
||
const cost = buildCostSummary(snapshot);
|
||
const latestIssue = latestDiagnosticIssue(doctorResults, auditEvents);
|
||
return {
|
||
doctor: {
|
||
ok: doctorResults.filter((result) => result.severity === 'ok').length,
|
||
warn: doctorResults.filter((result) => result.severity === 'warn').length,
|
||
error: doctorResults.filter((result) => result.severity === 'error').length,
|
||
},
|
||
audit: {
|
||
info: auditEvents.filter((event) => stringValue(event.level) === 'info').length,
|
||
warn: auditEvents.filter((event) => stringValue(event.level) === 'warn').length,
|
||
error: auditEvents.filter((event) => stringValue(event.level) === 'error').length,
|
||
},
|
||
cost: {
|
||
request_count: cost.request_count,
|
||
estimated: Boolean(cost.estimated),
|
||
updated_at: cost.updated_at ?? null,
|
||
},
|
||
latest_issue: latestIssue,
|
||
};
|
||
}
|
||
|
||
function latestDiagnosticIssue(
|
||
doctorResults: DiagResult[],
|
||
auditEvents: Array<Record<string, unknown>>,
|
||
): DigitalEmployeeDiagnosticSummary['latest_issue'] {
|
||
const doctorError = latestDoctorIssue(doctorResults, 'error');
|
||
if (doctorError) return doctorError;
|
||
const auditError = latestAuditIssue(auditEvents, 'error');
|
||
if (auditError) return auditError;
|
||
const doctorWarn = latestDoctorIssue(doctorResults, 'warn');
|
||
if (doctorWarn) return doctorWarn;
|
||
return latestAuditIssue(auditEvents, 'warn');
|
||
}
|
||
|
||
function latestDoctorIssue(
|
||
doctorResults: DiagResult[],
|
||
level: 'warn' | 'error',
|
||
): DigitalEmployeeDiagnosticSummary['latest_issue'] {
|
||
const result = doctorResults
|
||
.filter((item) => item.severity === level)
|
||
.sort((left, right) => stringValue(right.created_at).localeCompare(stringValue(left.created_at)))[0];
|
||
if (!result) return null;
|
||
return {
|
||
id: stringValue(result.id) || `${result.category}:${level}`,
|
||
source: 'doctor',
|
||
level,
|
||
category: stringValue(result.category) || 'diagnostic',
|
||
message: result.message,
|
||
occurred_at: result.created_at ?? null,
|
||
};
|
||
}
|
||
|
||
function latestAuditIssue(
|
||
auditEvents: Array<Record<string, unknown>>,
|
||
level: 'warn' | 'error',
|
||
): DigitalEmployeeDiagnosticSummary['latest_issue'] {
|
||
const event = auditEvents.find((item) => stringValue(item.level) === level);
|
||
if (!event) return null;
|
||
return {
|
||
id: stringValue(event.audit_id) || `${stringValue(event.category) || 'audit'}:${level}`,
|
||
source: 'audit',
|
||
level,
|
||
category: stringValue(event.category) || stringValue(event.entity_type) || 'audit',
|
||
message: stringValue(event.message) || stringValue(event.action) || '审计事件需要关注',
|
||
occurred_at: stringValue(event.occurred_at) || null,
|
||
};
|
||
}
|
||
|
||
function auditRows(snapshot: QimingclawSnapshot | null): BusinessViewRow[] {
|
||
return buildAuditEvents(snapshot, new URLSearchParams({ limit: '300' })).map((event) => ({
|
||
...event,
|
||
audit_id: stringValue(event.audit_id),
|
||
status: stringValue(event.level) || 'info',
|
||
status_label: auditLevelLabel(stringValue(event.level)),
|
||
entity_id: stringValue(event.entity_id) || stringValue(event.audit_id),
|
||
updated_at: stringValue(event.occurred_at),
|
||
source: BUSINESS_VIEW_SOURCE,
|
||
}));
|
||
}
|
||
|
||
function filterAuditRows(rows: BusinessViewRow[], searchParams: URLSearchParams): BusinessViewRow[] {
|
||
const category = stringValue(searchParams.get('category')) || stringValue(searchParams.get('kind'));
|
||
const level = stringValue(searchParams.get('level'));
|
||
const id = stringValue(searchParams.get('id'));
|
||
return filterBusinessRows(rows, searchParams)
|
||
.filter((row) => !category || stringValue(row.category) === category || stringValue(row.entity_type) === category)
|
||
.filter((row) => !level || stringValue(row.level) === level)
|
||
.filter((row) => !id || stringValue(row.entity_id) === id || stringValue(row.audit_id).includes(id));
|
||
}
|
||
|
||
function auditLevelLabel(level: string): string {
|
||
if (level === 'error') return '异常';
|
||
if (level === 'warn') return '警告';
|
||
return '信息';
|
||
}
|
||
|
||
function buildBusinessViewResponse(kind: BusinessViewKind, snapshot: QimingclawSnapshot | null, searchParams: URLSearchParams): Record<string, unknown> {
|
||
const rowsByKind: Record<BusinessViewKind, BusinessViewRow[]> = {
|
||
plans: businessPlanRows(snapshot),
|
||
'plan-steps': planStepRows(snapshot),
|
||
'plan-step-graph': planStepGraphRows(snapshot),
|
||
tasks: businessTaskRows(snapshot),
|
||
runs: businessRunRows(snapshot),
|
||
events: businessEventRows(snapshot),
|
||
artifacts: businessArtifactRows(snapshot),
|
||
approvals: businessApprovalRows(snapshot),
|
||
'approval-history': approvalHistoryRows(snapshot),
|
||
'route-decisions': routeDecisionRows(snapshot),
|
||
notifications: notificationRows(snapshot, notificationAdapterState(snapshot)),
|
||
audits: auditRows(snapshot),
|
||
};
|
||
const rows = kind === 'route-decisions'
|
||
? filterRouteDecisionRows(rowsByKind[kind], searchParams)
|
||
: kind === 'plan-steps' || kind === 'plan-step-graph'
|
||
? filterPlanStepRows(rowsByKind[kind], searchParams)
|
||
: kind === 'approval-history'
|
||
? filterApprovalHistoryRows(rowsByKind[kind], searchParams)
|
||
: kind === 'notifications'
|
||
? filterNotificationRows(rowsByKind[kind], searchParams)
|
||
: kind === 'audits'
|
||
? filterAuditRows(rowsByKind[kind], searchParams)
|
||
: filterBusinessRows(rowsByKind[kind], searchParams);
|
||
return {
|
||
...paginateBusinessRows(rows, searchParams),
|
||
source: BUSINESS_VIEW_SOURCE,
|
||
};
|
||
}
|
||
|
||
function planStepRows(snapshot: QimingclawSnapshot | null): BusinessViewRow[] {
|
||
return runtimePlanSteps(snapshot)
|
||
.map((step) => {
|
||
const payload = asRecord(step.payload) ?? {};
|
||
const dependencyGraph = asRecord(payload.dependencyGraph ?? payload.dependency_graph) ?? {};
|
||
const lastDispatch = asRecord(payload.lastDispatch ?? payload.last_dispatch) ?? {};
|
||
const lease = activePlanStepDispatchLease(payload);
|
||
const readiness = planStepDispatchReadiness(step, snapshot, payload);
|
||
const blockedDependencies = uniqueStrings(arrayValue(dependencyGraph.blockedDependencies ?? dependencyGraph.blocked_dependencies));
|
||
const waitingDependencies = uniqueStrings(arrayValue(dependencyGraph.waitingDependencies ?? dependencyGraph.waiting_dependencies));
|
||
const satisfiedDependencies = uniqueStrings(arrayValue(dependencyGraph.satisfiedDependencies ?? dependencyGraph.satisfied_dependencies));
|
||
return {
|
||
step_id: step.id,
|
||
node_id: step.id,
|
||
remote_id: step.remoteId ?? null,
|
||
plan_id: step.planId,
|
||
title: step.title,
|
||
status: step.status,
|
||
seq: step.seq,
|
||
depends_on: step.dependsOn,
|
||
dependency_count: step.dependsOn.length,
|
||
dependency_status: stringValue(dependencyGraph.status) || stepDependencyStatus(step, blockedDependencies, waitingDependencies),
|
||
blocked_dependencies: blockedDependencies,
|
||
blocked_dependency_count: blockedDependencies.length,
|
||
blocked_dependency_details: planStepDependencyDetails(blockedDependencies, snapshot),
|
||
waiting_dependencies: waitingDependencies,
|
||
waiting_dependency_count: waitingDependencies.length,
|
||
satisfied_dependencies: satisfiedDependencies,
|
||
preferred_skill_ids: step.preferredSkillIds,
|
||
task_id: readiness.taskId,
|
||
latest_run_id: readiness.latestRunId,
|
||
dispatchable: readiness.dispatchable,
|
||
skip_reason: readiness.skipReason,
|
||
last_dispatch_status: stringValue(lastDispatch.status) || null,
|
||
last_dispatch_at: stringValue(lastDispatch.occurredAt ?? lastDispatch.occurred_at) || null,
|
||
lease,
|
||
lease_id: stringValue(lease?.lease_id ?? lease?.leaseId) || null,
|
||
lease_state: stringValue(lease?.state) || null,
|
||
lease_owner_device_id: stringValue(lease?.owner_device_id ?? lease?.ownerDeviceId) || null,
|
||
lease_acquired_at: stringValue(lease?.acquired_at ?? lease?.acquiredAt) || null,
|
||
lease_expires_at: stringValue(lease?.expires_at ?? lease?.expiresAt) || null,
|
||
lease_released_at: stringValue(lease?.released_at ?? lease?.releasedAt) || null,
|
||
lease_release_reason: stringValue(lease?.release_reason ?? lease?.releaseReason) || null,
|
||
lease_active: Boolean(lease),
|
||
sync_status: step.syncStatus,
|
||
last_synced_at: step.lastSyncedAt ?? null,
|
||
sync_error: step.syncError ?? null,
|
||
created_at: step.createdAt,
|
||
updated_at: step.updatedAt,
|
||
entity_type: 'plan_step',
|
||
entity_id: step.id,
|
||
source: BUSINESS_VIEW_SOURCE,
|
||
};
|
||
})
|
||
.sort((left, right) => stringValue(left.plan_id).localeCompare(stringValue(right.plan_id)) || Number(left.seq ?? 0) - Number(right.seq ?? 0) || stringValue(left.step_id).localeCompare(stringValue(right.step_id)));
|
||
}
|
||
|
||
function planStepGraphRows(snapshot: QimingclawSnapshot | null): BusinessViewRow[] {
|
||
return planStepRows(snapshot).map((row) => ({
|
||
node_id: stringValue(row.node_id) || stringValue(row.step_id),
|
||
step_id: stringValue(row.step_id),
|
||
plan_id: stringValue(row.plan_id) || null,
|
||
title: stringValue(row.title),
|
||
status: stringValue(row.status),
|
||
seq: row.seq,
|
||
depends_on: arrayValue(row.depends_on),
|
||
dependency_status: stringValue(row.dependency_status) || null,
|
||
blocked_dependencies: arrayValue(row.blocked_dependencies),
|
||
blocked_dependency_details: arrayValue(row.blocked_dependency_details),
|
||
waiting_dependencies: arrayValue(row.waiting_dependencies),
|
||
satisfied_dependencies: arrayValue(row.satisfied_dependencies),
|
||
task_id: stringValue(row.task_id) || null,
|
||
latest_run_id: stringValue(row.latest_run_id) || null,
|
||
dispatchable: row.dispatchable === true,
|
||
skip_reason: stringValue(row.skip_reason) || null,
|
||
lease: asRecord(row.lease) ?? null,
|
||
lease_id: stringValue(row.lease_id) || null,
|
||
lease_state: stringValue(row.lease_state) || null,
|
||
lease_owner_device_id: stringValue(row.lease_owner_device_id) || null,
|
||
lease_acquired_at: stringValue(row.lease_acquired_at) || null,
|
||
lease_expires_at: stringValue(row.lease_expires_at) || null,
|
||
lease_released_at: stringValue(row.lease_released_at) || null,
|
||
lease_release_reason: stringValue(row.lease_release_reason) || null,
|
||
lease_active: row.lease_active === true,
|
||
sync_status: stringValue(row.sync_status) || null,
|
||
updated_at: stringValue(row.updated_at) || null,
|
||
entity_type: 'plan_step_graph_node',
|
||
entity_id: stringValue(row.step_id),
|
||
source: BUSINESS_VIEW_SOURCE,
|
||
}));
|
||
}
|
||
|
||
function filterPlanStepRows(rows: BusinessViewRow[], searchParams: URLSearchParams): BusinessViewRow[] {
|
||
const planId = stringValue(searchParams.get('plan_id'));
|
||
const stepId = stringValue(searchParams.get('step_id')) || stringValue(searchParams.get('id'));
|
||
const status = stringValue(searchParams.get('status'));
|
||
const syncStatus = stringValue(searchParams.get('sync_status'));
|
||
return filterBusinessRows(rows, searchParams)
|
||
.filter((row) => !planId || stringValue(row.plan_id) === planId)
|
||
.filter((row) => !stepId || stringValue(row.step_id) === stepId || stringValue(row.node_id) === stepId || stringValue(row.entity_id) === stepId)
|
||
.filter((row) => !status || stringValue(row.status) === status)
|
||
.filter((row) => !syncStatus || stringValue(row.sync_status) === syncStatus);
|
||
}
|
||
|
||
function stepDependencyStatus(step: QimingclawPlanStepRecord, blockedDependencies: string[], waitingDependencies: string[]): string {
|
||
if (blockedDependencies.length > 0) return 'blocked';
|
||
if (waitingDependencies.length > 0) return 'waiting';
|
||
if (step.dependsOn.length > 0) return 'ready';
|
||
return 'independent';
|
||
}
|
||
|
||
function planStepDispatchReadiness(
|
||
step: QimingclawPlanStepRecord,
|
||
snapshot: QimingclawSnapshot | null,
|
||
payload: Record<string, unknown>,
|
||
): { taskId: string | null; latestRunId: string | null; dispatchable: boolean; skipReason: string | null } {
|
||
const tasks = runtimePlanTasks(snapshot, step.planId);
|
||
const task = tasks.find((candidate) => taskStepId(candidate) === step.id)
|
||
?? tasks.find((candidate) => !isTerminalRuntimeTaskStatus(candidate.status))
|
||
?? null;
|
||
const taskId = task?.id ?? null;
|
||
const latestRunId = task ? latestRunForTask(runtimeRuns(snapshot), task.id)?.id ?? null : null;
|
||
const lease = activePlanStepDispatchLease(payload);
|
||
let skipReason: string | null = null;
|
||
if (lease) skipReason = 'lease_active';
|
||
else if (step.status.toLowerCase() !== 'ready') skipReason = 'not_ready';
|
||
else if (!task) skipReason = 'missing_task';
|
||
else if (isTerminalRuntimeTaskStatus(task.status)) skipReason = 'task_terminal';
|
||
else if (runtimeRuns(snapshot).some((run) => run.taskId === task.id && isActiveRuntimeRunStatus(run.status))) skipReason = 'task_already_running';
|
||
else if (runtimeApprovals(snapshot).some((approval) => isOpenRuntimeApprovalStatus(approval.status) && (approval.planId === step.planId || approval.taskId === task.id || stringValue(asRecord(approval.payload)?.stepId ?? asRecord(approval.payload)?.step_id) === step.id))) skipReason = 'approval_pending';
|
||
else if (payload.auto_dispatch === false || payload.autoDispatch === false) skipReason = 'auto_dispatch_disabled';
|
||
return { taskId, latestRunId, dispatchable: !skipReason, skipReason };
|
||
}
|
||
|
||
function planStepDependencyDetails(dependencyIds: string[], snapshot: QimingclawSnapshot | null): BusinessViewRow[] {
|
||
const stepsById = new Map(runtimePlanSteps(snapshot).map((step) => [step.id, step]));
|
||
return dependencyIds.map((dependencyId) => {
|
||
const dependency = stepsById.get(dependencyId);
|
||
if (!dependency) {
|
||
return {
|
||
step_id: dependencyId,
|
||
task_id: null,
|
||
latest_run_id: null,
|
||
title: dependencyId,
|
||
status: 'missing',
|
||
dependency_status: 'missing',
|
||
dispatchable: false,
|
||
skip_reason: 'missing_step',
|
||
};
|
||
}
|
||
const payload = asRecord(dependency.payload) ?? {};
|
||
const graph = asRecord(payload.dependencyGraph ?? payload.dependency_graph) ?? {};
|
||
const lease = activePlanStepDispatchLease(payload);
|
||
const readiness = planStepDispatchReadiness(dependency, snapshot, payload);
|
||
return {
|
||
step_id: dependency.id,
|
||
task_id: readiness.taskId,
|
||
latest_run_id: readiness.latestRunId,
|
||
title: dependency.title,
|
||
status: dependency.status,
|
||
dependency_status: stringValue(graph.status) || dependency.status,
|
||
dispatchable: readiness.dispatchable,
|
||
skip_reason: readiness.skipReason,
|
||
lease_state: stringValue(lease?.state) || null,
|
||
lease_active: Boolean(lease),
|
||
};
|
||
});
|
||
}
|
||
|
||
function activePlanStepDispatchLease(payload: Record<string, unknown>): Record<string, unknown> | null {
|
||
const lease = asRecord(payload.dispatchLease ?? payload.dispatch_lease);
|
||
if (!lease) return null;
|
||
const state = stringValue(lease.state) || 'active';
|
||
const expiresAt = stringValue(lease.expires_at ?? lease.expiresAt);
|
||
const leaseId = stringValue(lease.lease_id ?? lease.leaseId);
|
||
const ownerDeviceId = stringValue(lease.owner_device_id ?? lease.ownerDeviceId);
|
||
if (state !== 'active' || !expiresAt || expiresAt <= new Date().toISOString() || !leaseId || !ownerDeviceId) return null;
|
||
return lease;
|
||
}
|
||
|
||
function isTerminalRuntimeTaskStatus(status: string): boolean {
|
||
return ['completed', 'succeeded', 'success', 'done', 'skipped', 'cancelled', 'canceled'].includes(status.toLowerCase());
|
||
}
|
||
|
||
function isActiveRuntimeRunStatus(status: string): boolean {
|
||
return ['running', 'pending', 'queued', 'started'].includes(status.toLowerCase());
|
||
}
|
||
|
||
function isOpenRuntimeApprovalStatus(status: string): boolean {
|
||
return ['pending', 'reviewing', 'open', 'waiting'].includes(status.toLowerCase() || 'pending');
|
||
}
|
||
|
||
function routeDecisionRows(snapshot: QimingclawSnapshot | null): BusinessViewRow[] {
|
||
return runtimeEvents(snapshot)
|
||
.filter((event) => event.kind === 'route_decision')
|
||
.map((event) => {
|
||
const payload = asRecord(event.payload) ?? {};
|
||
const decision = routeDecisionFromRuntimePayload(payload, event);
|
||
const attentionLevel = routeDecisionAttentionLevel(decision);
|
||
return {
|
||
...decision,
|
||
route_decision_id: decision.id,
|
||
event_id: event.id,
|
||
status: decision.policy_result || 'accepted',
|
||
status_label: routeDecisionStatusLabel(decision),
|
||
attention_level: attentionLevel,
|
||
entity_type: 'route_decision',
|
||
entity_id: decision.id,
|
||
occurred_at: event.occurredAt,
|
||
created_at: event.createdAt,
|
||
updated_at: decision.recorded_at || event.occurredAt,
|
||
payload,
|
||
};
|
||
})
|
||
.sort((left, right) => stringValue(right.recorded_at).localeCompare(stringValue(left.recorded_at)) || stringValue(right.event_id).localeCompare(stringValue(left.event_id)));
|
||
}
|
||
|
||
function filterRouteDecisionRows(rows: BusinessViewRow[], searchParams: URLSearchParams): BusinessViewRow[] {
|
||
const routeKind = stringValue(searchParams.get('route_kind'));
|
||
const intentKind = stringValue(searchParams.get('intent_kind'));
|
||
const policyResult = stringValue(searchParams.get('policy_result'));
|
||
return filterBusinessRows(rows, searchParams)
|
||
.filter((row) => !routeKind || stringValue(row.route_kind) === routeKind)
|
||
.filter((row) => !intentKind || stringValue(row.intent_kind) === intentKind)
|
||
.filter((row) => !policyResult || stringValue(row.policy_result) === policyResult);
|
||
}
|
||
|
||
function notificationRows(snapshot: QimingclawSnapshot | null, state: AdapterState): BusinessViewRow[] {
|
||
const preferences = notificationPreferences(state);
|
||
return buildNotificationCandidates(snapshot, state)
|
||
.map((notification) => ({
|
||
notification_id: notification.notification_id,
|
||
kind: notification.kind,
|
||
level: notification.level,
|
||
status: notification.status,
|
||
title: notification.title,
|
||
body: notification.body,
|
||
plan_id: notification.plan_id,
|
||
task_id: notification.task_id,
|
||
correlation_id: notification.correlation_id,
|
||
created_at: notification.created_at,
|
||
updated_at: notification.replied_at || notification.dismissed_at || notification.read_at || notification.created_at,
|
||
read_at: notification.read_at ?? null,
|
||
dismissed_at: notification.dismissed_at ?? null,
|
||
replied_at: notification.replied_at ?? null,
|
||
muted_by_preferences: !notificationMatchesPreferences(notification, preferences),
|
||
entity_type: 'notification',
|
||
entity_id: notification.notification_id,
|
||
source: BUSINESS_VIEW_SOURCE,
|
||
}))
|
||
.sort((left, right) => stringValue(right.created_at).localeCompare(stringValue(left.created_at)) || stringValue(right.notification_id).localeCompare(stringValue(left.notification_id)));
|
||
}
|
||
|
||
function filterNotificationRows(rows: BusinessViewRow[], searchParams: URLSearchParams): BusinessViewRow[] {
|
||
const id = stringValue(searchParams.get('id'));
|
||
const kind = stringValue(searchParams.get('kind'));
|
||
const level = stringValue(searchParams.get('level'));
|
||
const muted = stringValue(searchParams.get('muted')).toLowerCase();
|
||
return filterBusinessRows(rows, searchParams)
|
||
.filter((row) => !id || stringValue(row.notification_id) === id || stringValue(row.correlation_id) === id || stringValue(row.entity_id) === id)
|
||
.filter((row) => !kind || stringValue(row.kind) === kind)
|
||
.filter((row) => !level || stringValue(row.level) === level)
|
||
.filter((row) => {
|
||
if (!muted) return true;
|
||
const mutedValue = row.muted_by_preferences === true;
|
||
if (['1', 'true', 'yes'].includes(muted)) return mutedValue;
|
||
if (['0', 'false', 'no'].includes(muted)) return !mutedValue;
|
||
return true;
|
||
});
|
||
}
|
||
|
||
function routeDecisionFromRuntimePayload(payload: Record<string, unknown>, event: QimingclawEventRecord): RouteDecisionRecord {
|
||
const decision = asRecord(payload.routeDecision ?? payload.route_decision ?? payload) ?? {};
|
||
return {
|
||
id: stringValue(decision.id) || event.id,
|
||
route_kind: stringValue(decision.route_kind ?? decision.routeKind) || 'ChatOnly',
|
||
intent_kind: stringValue(decision.intent_kind ?? decision.intentKind) || 'chat',
|
||
reason_codes: uniqueStrings(arrayValue(decision.reason_codes ?? decision.reasonCodes)),
|
||
candidate_skills: uniqueStrings(arrayValue(decision.candidate_skills ?? decision.candidateSkills)),
|
||
context_refs: asRecord(decision.context_refs ?? decision.contextRefs) ?? {},
|
||
created_command_id: stringValue(decision.created_command_id ?? decision.createdCommandId) || null,
|
||
correlation_id: stringValue(decision.correlation_id ?? decision.correlationId) || event.id,
|
||
creates_plan: Boolean(decision.creates_plan ?? decision.createsPlan),
|
||
creates_task_run: Boolean(decision.creates_task_run ?? decision.createsTaskRun),
|
||
approval_mode: stringValue(decision.approval_mode ?? decision.approvalMode) || null,
|
||
policy_result: stringValue(decision.policy_result ?? decision.policyResult) || 'accepted',
|
||
recorded_at: stringValue(decision.recorded_at ?? decision.recordedAt) || event.occurredAt,
|
||
entrypoint: stringValue(decision.entrypoint) || null,
|
||
actor: stringValue(decision.actor) || null,
|
||
};
|
||
}
|
||
|
||
function routeDecisionAttentionLevel(decision: RouteDecisionRecord): 'info' | 'action' | 'warn' | 'error' {
|
||
if (decision.policy_result && decision.policy_result !== 'accepted') return 'error';
|
||
if (decision.reason_codes.includes('candidate_skills_disabled') || decision.reason_codes.includes('route_action_missing_context')) return 'warn';
|
||
if (decision.created_command_id) return 'action';
|
||
return 'info';
|
||
}
|
||
|
||
function routeDecisionStatusLabel(decision: RouteDecisionRecord): string {
|
||
const attentionLevel = routeDecisionAttentionLevel(decision);
|
||
if (attentionLevel === 'error') return '策略拒绝';
|
||
if (attentionLevel === 'warn') return '需要关注';
|
||
if (decision.created_command_id) return '已映射命令';
|
||
return '已记录';
|
||
}
|
||
|
||
function buildRouteDecisionSummary(snapshot: QimingclawSnapshot | null): DigitalEmployeeRouteSummary {
|
||
const rows = routeDecisionRows(snapshot);
|
||
const latest = rows[0] ?? null;
|
||
return {
|
||
total: rows.length,
|
||
mapped_count: rows.filter((row) => stringValue(row.created_command_id)).length,
|
||
attention_count: rows.filter((row) => ['warn', 'error'].includes(stringValue(row.attention_level))).length,
|
||
latest: latest
|
||
? {
|
||
id: stringValue(latest.route_decision_id),
|
||
route_kind: stringValue(latest.route_kind),
|
||
intent_kind: stringValue(latest.intent_kind),
|
||
status_label: stringValue(latest.status_label),
|
||
attention_level: stringValue(latest.attention_level),
|
||
created_command_id: stringValue(latest.created_command_id) || null,
|
||
recorded_at: stringValue(latest.recorded_at),
|
||
}
|
||
: null,
|
||
};
|
||
}
|
||
|
||
function businessPlanRows(snapshot: QimingclawSnapshot | null): BusinessViewRow[] {
|
||
const runtimeById = new Map(runtimePlans(snapshot).map((plan) => [plan.id, plan]));
|
||
const tasks = buildTasks(null, snapshot);
|
||
const runs = buildTasksResponse(null, snapshot).runs;
|
||
const events = buildCanonicalEvents(snapshot, tasks, runs);
|
||
return filterPlans(null, snapshot).map((plan) => {
|
||
const runtime = runtimeById.get(plan.plan_id);
|
||
const relatedTasks = tasks.filter((task) => task.plan_id === plan.plan_id);
|
||
const relatedRuns = runs.filter((run) => run.plan_id === plan.plan_id);
|
||
const latestEventAt = events
|
||
.filter((event) => event.plan_id === plan.plan_id)
|
||
.map((event) => stringValue(event.occurred_at ?? event.timestamp))
|
||
.filter(Boolean)
|
||
.sort()
|
||
.pop() || null;
|
||
return {
|
||
plan_id: plan.plan_id,
|
||
remote_id: runtime?.remoteId ?? null,
|
||
title: plan.title,
|
||
objective: plan.objective ?? null,
|
||
status: plan.status,
|
||
task_count: relatedTasks.length,
|
||
run_count: relatedRuns.length,
|
||
latest_event_at: latestEventAt,
|
||
sync_status: (runtime?.syncStatus ?? stringValue(plan.sync_status)) || null,
|
||
created_at: plan.created_at,
|
||
updated_at: stringValue(plan.updated_at) || runtime?.updatedAt || plan.created_at,
|
||
payload: runtime?.payload ?? compactRecord({ source: plan.source, steps: plan.steps }),
|
||
};
|
||
});
|
||
}
|
||
|
||
function businessTaskRows(snapshot: QimingclawSnapshot | null): BusinessViewRow[] {
|
||
const runtimeById = new Map(runtimeTasks(snapshot).map((task) => [task.id, task]));
|
||
return buildTasks(null, snapshot).map((task) => {
|
||
const runtime = runtimeById.get(task.task_id);
|
||
return {
|
||
task_id: task.task_id,
|
||
remote_id: runtime?.remoteId ?? null,
|
||
plan_id: task.plan_id ?? null,
|
||
title: task.title,
|
||
status: task.status,
|
||
assigned_skill_id: task.assigned_skill_id || runtime?.assignedSkillId || null,
|
||
sync_status: (runtime?.syncStatus ?? stringValue(task.sync_status)) || null,
|
||
created_at: task.created_at,
|
||
updated_at: task.updated_at,
|
||
payload: runtime?.payload ?? compactRecord({ step_id: task.step_id, description: task.description }),
|
||
};
|
||
});
|
||
}
|
||
|
||
function businessRunRows(snapshot: QimingclawSnapshot | null): BusinessViewRow[] {
|
||
const runtimeById = new Map(runtimeRuns(snapshot).map((run) => [run.id, run]));
|
||
return buildTasksResponse(null, snapshot).runs.map((run) => {
|
||
const runtime = runtimeById.get(run.run_id);
|
||
const startedAt = runtime?.startedAt ?? run.created_at;
|
||
const finishedAt = runtime?.finishedAt ?? run.completed_at ?? null;
|
||
const latestRunEvent = (run.events ?? [])
|
||
.slice()
|
||
.sort((left, right) => stringValue(right.occurred_at).localeCompare(stringValue(left.occurred_at)))[0];
|
||
return {
|
||
run_id: run.run_id,
|
||
remote_id: runtime?.remoteId ?? null,
|
||
plan_id: run.plan_id ?? null,
|
||
task_id: run.task_id || null,
|
||
status: runtime?.status ?? run.lifecycle,
|
||
started_at: startedAt ?? null,
|
||
finished_at: finishedAt,
|
||
duration_ms: durationMs(startedAt, finishedAt),
|
||
last_event_message: latestRunEvent?.message ?? null,
|
||
sync_status: (runtime?.syncStatus ?? stringValue(run.sync_status)) || null,
|
||
created_at: runtime?.createdAt ?? run.created_at,
|
||
payload: runtime?.payload ?? compactRecord({ lifecycle: run.lifecycle, attempt_no: run.attempt_no }),
|
||
};
|
||
});
|
||
}
|
||
|
||
function businessEventRows(snapshot: QimingclawSnapshot | null): BusinessViewRow[] {
|
||
const tasks = buildTasks(null, snapshot);
|
||
const runs = buildTasksResponse(null, snapshot).runs;
|
||
const runtimeById = new Map(runtimeEvents(snapshot).map((event) => [event.id, event]));
|
||
return buildCanonicalEvents(snapshot, tasks, runs).map((event) => {
|
||
const runtime = runtimeById.get(event.event_id);
|
||
const planId = stringValue(event.plan_id) || runtime?.planId || null;
|
||
const taskId = stringValue(event.task_id) || runtime?.taskId || null;
|
||
return {
|
||
event_id: event.event_id,
|
||
remote_id: runtime?.remoteId ?? null,
|
||
plan_id: planId,
|
||
task_id: taskId,
|
||
run_id: runtime?.runId ?? null,
|
||
kind: event.kind ?? event.event_type ?? runtime?.kind ?? null,
|
||
message: event.message ?? runtime?.message ?? null,
|
||
occurred_at: stringValue(event.occurred_at ?? event.timestamp) || runtime?.occurredAt,
|
||
sync_status: runtime?.syncStatus ?? null,
|
||
payload: runtime?.payload ?? compactRecord({ aggregate_type: event.aggregate_type, aggregate_id: event.aggregate_id }),
|
||
};
|
||
});
|
||
}
|
||
|
||
function businessArtifactRows(snapshot: QimingclawSnapshot | null): BusinessViewRow[] {
|
||
const runtimeById = new Map(runtimeArtifacts(snapshot).map((artifact) => [artifact.id, artifact]));
|
||
const artifacts = buildArtifacts(snapshot);
|
||
return artifacts.map((artifact) => {
|
||
const artifactId = stringValue(artifact.artifact_id) || stringValue(artifact.subject_id);
|
||
const runtime = runtimeById.get(artifactId);
|
||
const entity = businessEntityFromRefs({
|
||
plan_id: artifact.plan_id,
|
||
task_id: artifact.task_id,
|
||
run_id: artifact.run_id,
|
||
fallback_type: 'artifact',
|
||
fallback_id: artifact.subject_id ?? artifactId,
|
||
});
|
||
const lifecycle = artifactLifecycleSummary(snapshot, artifactId);
|
||
const version = artifactVersionMeta(artifacts, artifact);
|
||
const delivery = artifactDeliverySummary(artifact);
|
||
return {
|
||
...artifact,
|
||
artifact_id: artifactId,
|
||
remote_id: (runtime?.remoteId ?? stringValue(artifact.remote_id)) || null,
|
||
entity_type: entity.entity_type,
|
||
entity_id: entity.entity_id,
|
||
sync_status: (runtime?.syncStatus ?? stringValue(artifact.sync_status)) || null,
|
||
version: version.version,
|
||
version_key: version.version_key,
|
||
version_rank: version.version_rank,
|
||
retention_status: lifecycle.retention_status,
|
||
retention_until: lifecycle.retention_until,
|
||
last_retention_action: lifecycle.last_retention_action,
|
||
last_access_status: stringValue(asRecord(artifact.access)?.last_access_status) || null,
|
||
delivery_summary: delivery,
|
||
};
|
||
});
|
||
}
|
||
|
||
function artifactDetailRow(snapshot: QimingclawSnapshot | null, artifactId: string): BusinessViewRow | null {
|
||
const row = businessArtifactRows(snapshot)
|
||
.find((artifact) => stringValue(artifact.artifact_id) === artifactId || stringValue(artifact.remote_id) === artifactId) ?? null;
|
||
if (!row) return null;
|
||
return {
|
||
...row,
|
||
versions: artifactVersionRows(snapshot, stringValue(row.artifact_id)),
|
||
lifecycle_events: artifactLifecycleRows(snapshot).filter((event) => stringValue(event.artifact_id) === stringValue(row.artifact_id)).slice(0, 20),
|
||
};
|
||
}
|
||
|
||
function artifactVersionRows(snapshot: QimingclawSnapshot | null, artifactId: string): BusinessViewRow[] {
|
||
const artifacts = buildArtifacts(snapshot);
|
||
const target = artifacts.find((artifact) => stringValue(artifact.artifact_id) === artifactId || stringValue(artifact.subject_id) === artifactId);
|
||
if (!target) return [];
|
||
const groupKey = artifactVersionGroupKey(target);
|
||
return artifacts
|
||
.filter((artifact) => artifactVersionGroupKey(artifact) === groupKey)
|
||
.sort((left, right) => stringValue(left.created_at).localeCompare(stringValue(right.created_at)))
|
||
.map((artifact, index) => {
|
||
const meta = artifactVersionMeta(artifacts, artifact);
|
||
return {
|
||
artifact_id: stringValue(artifact.artifact_id) || stringValue(artifact.subject_id),
|
||
name: stringValue(artifact.name) || null,
|
||
version: meta.version || `local-v${index + 1}`,
|
||
version_key: meta.version_key,
|
||
version_rank: index + 1,
|
||
delivery_summary: artifactDeliverySummary(artifact),
|
||
retention_status: artifactLifecycleSummary(snapshot, stringValue(artifact.artifact_id)).retention_status,
|
||
created_at: stringValue(artifact.created_at) || null,
|
||
source_label: stringValue(artifact.source_label) || null,
|
||
};
|
||
});
|
||
}
|
||
|
||
function businessApprovalRows(snapshot: QimingclawSnapshot | null): BusinessViewRow[] {
|
||
const runtimeById = new Map(runtimeApprovals(snapshot).map((approval) => [approval.id, approval]));
|
||
return buildApprovals(snapshot).map((approval) => {
|
||
const approvalId = stringValue(approval.approval_id);
|
||
const runtime = runtimeById.get(approvalId);
|
||
const summary = approvalActionSummary(snapshot, approvalId, approval);
|
||
const entity = businessEntityFromRefs({
|
||
plan_id: approval.plan_id,
|
||
task_id: approval.task_id,
|
||
run_id: approval.run_id,
|
||
fallback_type: stringValue(approval.source) === 'qimingclaw-sync' ? 'sync_outbox' : 'approval',
|
||
fallback_id: approval.task_id || approvalId,
|
||
});
|
||
return {
|
||
...approval,
|
||
approval_id: approvalId,
|
||
remote_id: (runtime?.remoteId ?? stringValue(approval.remote_id)) || null,
|
||
entity_type: entity.entity_type,
|
||
entity_id: entity.entity_id,
|
||
sync_status: (runtime?.syncStatus ?? stringValue(approval.sync_status)) || null,
|
||
risk_level: summary.risk_level,
|
||
sla_status: summary.sla_status,
|
||
due_at: summary.due_at,
|
||
last_action: summary.last_action,
|
||
last_actor: summary.last_actor,
|
||
comment_count: summary.comment_count,
|
||
delegate_to: summary.delegate_to,
|
||
};
|
||
});
|
||
}
|
||
|
||
function approvalDetailRow(snapshot: QimingclawSnapshot | null, approvalId: string): BusinessViewRow | null {
|
||
const row = businessApprovalRows(snapshot)
|
||
.find((approval) => stringValue(approval.approval_id) === approvalId || stringValue(approval.remote_id) === approvalId) ?? null;
|
||
if (!row) return null;
|
||
return {
|
||
...row,
|
||
timeline: buildApprovalTimeline(stringValue(row.approval_id), snapshot).events,
|
||
};
|
||
}
|
||
|
||
function approvalActionRows(snapshot: QimingclawSnapshot | null): BusinessViewRow[] {
|
||
return runtimeEvents(snapshot)
|
||
.filter((event) => ['approval_action_recorded', 'approval_action_rejected'].includes(event.kind))
|
||
.map((event) => {
|
||
const payload = asRecord(event.payload) ?? {};
|
||
const delegate = asRecord(payload.delegate_summary);
|
||
const comment = asRecord(payload.comment_summary);
|
||
const sla = asRecord(payload.sla_summary);
|
||
const risk = asRecord(payload.risk_summary);
|
||
return {
|
||
action_id: event.id,
|
||
event_id: event.id,
|
||
kind: event.kind,
|
||
approval_id: stringValue(payload.approval_id) || null,
|
||
action: stringValue(payload.action) || null,
|
||
status: stringValue(payload.status) || null,
|
||
comment_preview: stringValue(comment?.preview) || null,
|
||
comment_length: numberValue(comment?.length),
|
||
delegate_to: stringValue(delegate?.label ?? delegate?.target) || null,
|
||
sla_status: stringValue(sla?.sla_status) || null,
|
||
due_at: stringValue(sla?.due_at) || null,
|
||
risk_level: stringValue(risk?.risk_level) || null,
|
||
actor: stringValue(payload.actor) || null,
|
||
source: stringValue(payload.source) || null,
|
||
plan_id: (event.planId ?? stringValue(payload.plan_id)) || null,
|
||
task_id: (event.taskId ?? stringValue(payload.task_id)) || null,
|
||
run_id: (event.runId ?? stringValue(payload.run_id)) || null,
|
||
message: event.message,
|
||
occurred_at: event.occurredAt,
|
||
sync_status: event.syncStatus ?? null,
|
||
payload,
|
||
};
|
||
})
|
||
.sort((left, right) => stringValue(right.occurred_at).localeCompare(stringValue(left.occurred_at)));
|
||
}
|
||
|
||
function approvalHistoryRows(snapshot: QimingclawSnapshot | null): BusinessViewRow[] {
|
||
const approvalRows = new Map(businessApprovalRows(snapshot).map((approval) => [stringValue(approval.approval_id), approval]));
|
||
const actionRows = approvalActionRows(snapshot).map((action) => {
|
||
const approvalId = stringValue(action.approval_id);
|
||
const approval = approvalRows.get(approvalId);
|
||
return {
|
||
history_id: stringValue(action.action_id),
|
||
event_id: stringValue(action.event_id),
|
||
approval_id: approvalId || null,
|
||
action: stringValue(action.action) || null,
|
||
status: stringValue(action.status) || null,
|
||
actor: stringValue(action.actor) || null,
|
||
risk_level: stringValue(action.risk_level) || null,
|
||
due_at: stringValue(action.due_at) || null,
|
||
delegate_to: stringValue(action.delegate_to) || null,
|
||
comment_length: numberValue(action.comment_length),
|
||
message: stringValue(action.message) || null,
|
||
plan_id: stringValue(action.plan_id) || stringValue(approval?.plan_id) || null,
|
||
task_id: stringValue(action.task_id) || stringValue(approval?.task_id) || null,
|
||
run_id: stringValue(action.run_id) || stringValue(approval?.run_id) || null,
|
||
occurred_at: stringValue(action.occurred_at) || null,
|
||
updated_at: stringValue(action.occurred_at) || null,
|
||
sync_status: stringValue(action.sync_status) || null,
|
||
entity_type: 'approval_history',
|
||
entity_id: stringValue(action.action_id),
|
||
source: BUSINESS_VIEW_SOURCE,
|
||
};
|
||
});
|
||
const decisionRows = runtimeEvents(snapshot)
|
||
.filter((event) => event.kind === 'approval_decision')
|
||
.map((event) => {
|
||
const payload = asRecord(event.payload) ?? {};
|
||
const approvalId = stringValue(payload.approvalId ?? payload.approval_id) || event.id.split(':decision:')[0] || '';
|
||
const approval = approvalRows.get(approvalId);
|
||
return {
|
||
history_id: event.id,
|
||
event_id: event.id,
|
||
approval_id: approvalId || null,
|
||
action: 'decision',
|
||
status: stringValue(payload.nextStatus ?? payload.next_status ?? payload.decision) || null,
|
||
actor: stringValue(payload.actor) || stringValue(payload.source) || 'qimingclaw-approval-decision',
|
||
risk_level: stringValue(approval?.risk_level) || null,
|
||
due_at: stringValue(approval?.due_at) || null,
|
||
delegate_to: stringValue(approval?.delegate_to) || null,
|
||
comment_length: null,
|
||
message: event.message || null,
|
||
plan_id: event.planId || stringValue(payload.planId ?? payload.plan_id) || stringValue(approval?.plan_id) || null,
|
||
task_id: event.taskId || stringValue(payload.taskId ?? payload.task_id) || stringValue(approval?.task_id) || null,
|
||
run_id: event.runId || stringValue(payload.runId ?? payload.run_id) || stringValue(approval?.run_id) || null,
|
||
occurred_at: event.occurredAt,
|
||
updated_at: event.occurredAt,
|
||
sync_status: event.syncStatus ?? null,
|
||
entity_type: 'approval_history',
|
||
entity_id: event.id,
|
||
source: BUSINESS_VIEW_SOURCE,
|
||
};
|
||
});
|
||
return [...actionRows, ...decisionRows]
|
||
.sort((left, right) => stringValue(right.occurred_at).localeCompare(stringValue(left.occurred_at)) || stringValue(right.history_id).localeCompare(stringValue(left.history_id)));
|
||
}
|
||
|
||
function filterApprovalHistoryRows(rows: BusinessViewRow[], searchParams: URLSearchParams): BusinessViewRow[] {
|
||
const approvalId = stringValue(searchParams.get('approval_id')) || stringValue(searchParams.get('id'));
|
||
const action = stringValue(searchParams.get('action'));
|
||
const riskLevel = stringValue(searchParams.get('risk_level'));
|
||
return filterBusinessRows(rows, searchParams)
|
||
.filter((row) => !approvalId || stringValue(row.approval_id) === approvalId || stringValue(row.history_id) === approvalId || stringValue(row.event_id) === approvalId)
|
||
.filter((row) => !action || stringValue(row.action) === action)
|
||
.filter((row) => !riskLevel || stringValue(row.risk_level) === riskLevel);
|
||
}
|
||
|
||
function approvalActionSummary(
|
||
snapshot: QimingclawSnapshot | null,
|
||
approvalId: string,
|
||
approval: Record<string, unknown>,
|
||
): Record<string, unknown> {
|
||
const actions = approvalActionRows(snapshot).filter((event) => stringValue(event.approval_id) === approvalId);
|
||
const latest = actions[0];
|
||
const latestRisk = actions.find((event) => stringValue(event.risk_level));
|
||
const latestSla = actions.find((event) => {
|
||
const status = stringValue(event.sla_status);
|
||
return Boolean(status && status !== 'untracked');
|
||
});
|
||
const latestDelegate = actions.find((event) => stringValue(event.delegate_to));
|
||
const payload = asRecord(approval.payload);
|
||
const dueAt = stringValue(latestSla?.due_at) || stringValue(payload?.due_at ?? payload?.dueAt ?? payload?.timeout_at ?? payload?.timeoutAt);
|
||
const slaStatus = stringValue(latestSla?.sla_status) || approvalSlaStatus(dueAt);
|
||
return {
|
||
risk_level: stringValue(latestRisk?.risk_level) || 'normal',
|
||
sla_status: slaStatus,
|
||
due_at: dueAt || null,
|
||
last_action: stringValue(latest?.action) || null,
|
||
last_actor: stringValue(latest?.actor) || null,
|
||
comment_count: actions.filter((event) => stringValue(event.action) === 'comment').length,
|
||
delegate_to: stringValue(latestDelegate?.delegate_to) || null,
|
||
};
|
||
}
|
||
|
||
function approvalSlaStatus(dueAt: string): string {
|
||
if (!dueAt) return 'untracked';
|
||
const dueMs = Date.parse(dueAt);
|
||
if (!Number.isFinite(dueMs)) return 'untracked';
|
||
return dueMs < Date.now() ? 'timeout' : 'tracked';
|
||
}
|
||
|
||
function skillCallAuditRows(snapshot: QimingclawSnapshot | null): BusinessViewRow[] {
|
||
return runtimeEvents(snapshot)
|
||
.filter((event) => ['skill_call_allowed', 'skill_call_rejected', 'skill_call_observed'].includes(event.kind))
|
||
.map((event) => {
|
||
const payload = asRecord(event.payload) ?? {};
|
||
return {
|
||
audit_id: event.id,
|
||
event_id: event.id,
|
||
remote_id: event.remoteId ?? null,
|
||
decision: stringValue(payload.decision) || event.kind.replace('skill_call_', ''),
|
||
source: stringValue(payload.source) || null,
|
||
server_id: stringValue(payload.server_id) || null,
|
||
tool_name: stringValue(payload.tool_name) || null,
|
||
skill_id: stringValue(payload.skill_id) || null,
|
||
call_id: stringValue(payload.call_id) || null,
|
||
session_id: stringValue(payload.session_id) || null,
|
||
task_id: (event.taskId ?? stringValue(payload.task_id)) || null,
|
||
run_id: (event.runId ?? stringValue(payload.run_id)) || null,
|
||
reason_codes: Array.isArray(payload.reason_codes) ? payload.reason_codes : [],
|
||
message: event.message,
|
||
occurred_at: event.occurredAt,
|
||
sync_status: event.syncStatus ?? null,
|
||
payload,
|
||
};
|
||
})
|
||
.sort((left, right) => stringValue(right.occurred_at).localeCompare(stringValue(left.occurred_at)));
|
||
}
|
||
|
||
function filterSkillCallAuditRows(rows: BusinessViewRow[], searchParams: URLSearchParams): BusinessViewRow[] {
|
||
const skillId = stringValue(searchParams.get('skill_id'));
|
||
const serverId = stringValue(searchParams.get('server_id'));
|
||
const toolName = stringValue(searchParams.get('tool_name'));
|
||
const decision = stringValue(searchParams.get('decision'));
|
||
return rows
|
||
.filter((row) => !skillId || stringValue(row.skill_id) === skillId)
|
||
.filter((row) => !serverId || stringValue(row.server_id) === serverId)
|
||
.filter((row) => !toolName || stringValue(row.tool_name) === toolName)
|
||
.filter((row) => !decision || stringValue(row.decision) === decision);
|
||
}
|
||
|
||
function artifactAccessRows(snapshot: QimingclawSnapshot | null): BusinessViewRow[] {
|
||
return runtimeEvents(snapshot)
|
||
.filter((event) => ['artifact_access_allowed', 'artifact_access_rejected'].includes(event.kind))
|
||
.map((event) => {
|
||
const payload = asRecord(event.payload) ?? {};
|
||
return {
|
||
access_id: event.id,
|
||
event_id: event.id,
|
||
remote_id: event.remoteId ?? null,
|
||
artifact_id: stringValue(payload.artifact_id) || null,
|
||
action: stringValue(payload.action) || null,
|
||
status: stringValue(payload.status) || event.kind.replace('artifact_access_', ''),
|
||
reason_codes: Array.isArray(payload.reason_codes) ? payload.reason_codes : [],
|
||
actor: stringValue(payload.actor) || null,
|
||
source: stringValue(payload.source) || null,
|
||
plan_id: (event.planId ?? stringValue(payload.plan_id)) || null,
|
||
task_id: (event.taskId ?? stringValue(payload.task_id)) || null,
|
||
run_id: (event.runId ?? stringValue(payload.run_id)) || null,
|
||
message: event.message,
|
||
occurred_at: event.occurredAt,
|
||
sync_status: event.syncStatus ?? null,
|
||
payload,
|
||
};
|
||
})
|
||
.sort((left, right) => stringValue(right.occurred_at).localeCompare(stringValue(left.occurred_at)));
|
||
}
|
||
|
||
function filterArtifactAccessRows(rows: BusinessViewRow[], searchParams: URLSearchParams): BusinessViewRow[] {
|
||
const artifactId = stringValue(searchParams.get('artifact_id'));
|
||
const action = stringValue(searchParams.get('action'));
|
||
const status = stringValue(searchParams.get('status'));
|
||
return rows
|
||
.filter((row) => !artifactId || stringValue(row.artifact_id) === artifactId)
|
||
.filter((row) => !action || stringValue(row.action) === action)
|
||
.filter((row) => !status || stringValue(row.status) === status);
|
||
}
|
||
|
||
function artifactLifecycleRows(snapshot: QimingclawSnapshot | null): BusinessViewRow[] {
|
||
return runtimeEvents(snapshot)
|
||
.filter((event) => ['artifact_retention_marked', 'artifact_retention_rejected', 'artifact_version_observed'].includes(event.kind))
|
||
.map((event) => {
|
||
const payload = asRecord(event.payload) ?? {};
|
||
return {
|
||
lifecycle_id: event.id,
|
||
event_id: event.id,
|
||
kind: event.kind,
|
||
artifact_id: stringValue(payload.artifact_id) || null,
|
||
action: stringValue(payload.action) || null,
|
||
status: stringValue(payload.status) || null,
|
||
retention_status: stringValue(payload.retention_status) || null,
|
||
retention_until: stringValue(payload.retention_until) || null,
|
||
reason: stringValue(payload.reason) || null,
|
||
actor: stringValue(payload.actor) || null,
|
||
source: stringValue(payload.source) || null,
|
||
plan_id: (event.planId ?? stringValue(payload.plan_id)) || null,
|
||
task_id: (event.taskId ?? stringValue(payload.task_id)) || null,
|
||
run_id: (event.runId ?? stringValue(payload.run_id)) || null,
|
||
message: event.message,
|
||
occurred_at: event.occurredAt,
|
||
sync_status: event.syncStatus ?? null,
|
||
payload,
|
||
};
|
||
})
|
||
.sort((left, right) => stringValue(right.occurred_at).localeCompare(stringValue(left.occurred_at)));
|
||
}
|
||
|
||
function artifactLifecycleSummary(snapshot: QimingclawSnapshot | null, artifactId: string): Record<string, unknown> {
|
||
const latest = artifactLifecycleRows(snapshot)
|
||
.find((event) => stringValue(event.artifact_id) === artifactId && stringValue(event.kind) === 'artifact_retention_marked');
|
||
return {
|
||
retention_status: stringValue(latest?.retention_status) || 'unmanaged',
|
||
retention_until: stringValue(latest?.retention_until) || null,
|
||
last_retention_action: stringValue(latest?.action) || null,
|
||
last_retention_at: stringValue(latest?.occurred_at) || null,
|
||
};
|
||
}
|
||
|
||
function artifactRetentionSummaryForAction(
|
||
artifact: BusinessViewRow,
|
||
action: string,
|
||
body: Record<string, unknown>,
|
||
): Record<string, unknown> {
|
||
return {
|
||
previous_status: stringValue(artifact.retention_status) || 'unmanaged',
|
||
retention_status: retentionStatusForAction(action),
|
||
retention_until: stringValue(body.retention_until ?? body.retentionUntil) || null,
|
||
reason: stringValue(body.reason) || null,
|
||
};
|
||
}
|
||
|
||
function retentionStatusForAction(action: string): string | null {
|
||
if (action === 'mark_keep') return 'keep';
|
||
if (action === 'mark_expire') return 'expire_candidate';
|
||
if (action === 'mark_review') return 'review_required';
|
||
if (action === 'clear_retention') return 'unmanaged';
|
||
return null;
|
||
}
|
||
|
||
function artifactVersionSummary(artifact: BusinessViewRow): Record<string, unknown> {
|
||
return {
|
||
version: stringValue(artifact.version) || null,
|
||
version_key: stringValue(artifact.version_key) || null,
|
||
version_rank: numberValue(artifact.version_rank),
|
||
file_id: stringValue(artifact.file_id) || null,
|
||
workspace_id: stringValue(artifact.workspace_id) || null,
|
||
project_id: stringValue(artifact.project_id) || null,
|
||
created_at: stringValue(artifact.created_at) || null,
|
||
name: stringValue(artifact.name) || null,
|
||
};
|
||
}
|
||
|
||
function artifactDeliverySummary(artifact: Record<string, unknown>): Record<string, unknown> {
|
||
return {
|
||
delivery_status: stringValue(artifact.delivery_status) || null,
|
||
delivery_stage: stringValue(artifact.delivery_stage) || null,
|
||
workspace_id: stringValue(artifact.workspace_id) || null,
|
||
project_id: stringValue(artifact.project_id) || null,
|
||
file_id: stringValue(artifact.file_id) || null,
|
||
version: stringValue(artifact.version) || null,
|
||
file_size: numberValue(artifact.file_size),
|
||
source_tool: stringValue(artifact.source_tool) || null,
|
||
};
|
||
}
|
||
|
||
function artifactVersionMeta(artifacts: ArtifactEntry[], artifact: Record<string, unknown>): Record<string, unknown> {
|
||
const groupKey = artifactVersionGroupKey(artifact);
|
||
const group = artifacts
|
||
.filter((item) => artifactVersionGroupKey(item) === groupKey)
|
||
.sort((left, right) => stringValue(left.created_at).localeCompare(stringValue(right.created_at)));
|
||
const artifactId = stringValue(artifact.artifact_id) || stringValue(artifact.subject_id);
|
||
const index = Math.max(0, group.findIndex((item) => stringValue(item.artifact_id) === artifactId || stringValue(item.subject_id) === artifactId));
|
||
return {
|
||
version: stringValue(artifact.version) || `local-v${index + 1}`,
|
||
version_key: `${groupKey}:v${stringValue(artifact.version) || index + 1}`,
|
||
version_rank: index + 1,
|
||
};
|
||
}
|
||
|
||
function artifactVersionGroupKey(artifact: Record<string, unknown>): string {
|
||
const fileId = stringValue(artifact.file_id);
|
||
const workspaceId = stringValue(artifact.workspace_id);
|
||
const name = stringValue(artifact.name);
|
||
if (fileId) return `file:${workspaceId}:${fileId}:${name}`;
|
||
const artifactId = stringValue(artifact.artifact_id) || stringValue(artifact.subject_id);
|
||
if (artifactId) return `artifact:${artifactId}`;
|
||
return `fallback:${workspaceId}:${stringValue(artifact.project_id)}:${name || stringValue(artifact.uri)}`;
|
||
}
|
||
|
||
function dailyReportRows(snapshot: QimingclawSnapshot | null): BusinessViewRow[] {
|
||
return buildArtifacts(snapshot)
|
||
.filter(isDailyReportArtifact)
|
||
.map((artifact) => {
|
||
const payload = asRecord(artifact.payload) ?? {};
|
||
const artifactId = stringValue(artifact.artifact_id) || stringValue(payload.artifact_id) || stringValue(artifact.subject_id);
|
||
const reportId = stringValue(payload.report_id) || stringValue(artifact.report_id) || artifactId.replace(/:artifact:text$/, '');
|
||
const generatedAt = stringValue(payload.generated_at) || stringValue(artifact.created_at) || new Date().toISOString();
|
||
const date = stringValue(payload.date) || generatedAt.slice(0, 10);
|
||
return {
|
||
report_id: reportId,
|
||
artifact_id: artifactId,
|
||
event_id: stringValue(payload.event_id) || `${reportId}:event:generated`,
|
||
date,
|
||
title: stringValue(payload.title) || stringValue(artifact.name) || `${date} 数字员工日报`,
|
||
status: stringValue(payload.status) || 'ready',
|
||
summary: stringValue(payload.summary) || stringValue(artifact.value) || '',
|
||
totals: asRecord(payload.totals) ?? {},
|
||
detail_lines: arrayValue(payload.detail_lines),
|
||
artifact_sources: arrayValue(payload.artifact_sources),
|
||
filename: stringValue(payload.filename) || stringValue(artifact.name) || dailyReportFilename(date),
|
||
format: stringValue(payload.format) || 'text',
|
||
text_content: stringValue(payload.text_content) || stringValue(artifact.value),
|
||
generated_at: generatedAt,
|
||
sync_status: stringValue(artifact.sync_status) || null,
|
||
entity_type: 'artifact',
|
||
entity_id: artifactId,
|
||
plan_id: stringValue(artifact.plan_id) || null,
|
||
task_id: stringValue(artifact.task_id) || null,
|
||
run_id: stringValue(artifact.run_id) || null,
|
||
created_at: stringValue(artifact.created_at) || generatedAt,
|
||
updated_at: generatedAt,
|
||
payload,
|
||
};
|
||
})
|
||
.sort((left, right) => stringValue(right.generated_at).localeCompare(stringValue(left.generated_at)));
|
||
}
|
||
|
||
function isDailyReportArtifact(artifact: ArtifactEntry): boolean {
|
||
const payload = asRecord(artifact.payload) ?? {};
|
||
return stringValue(artifact.kind) === 'daily_report'
|
||
|| stringValue(payload.kind) === 'daily_report'
|
||
|| Boolean(stringValue(payload.report_id) && stringValue(payload.text_content));
|
||
}
|
||
|
||
function filterDailyReportRows(rows: BusinessViewRow[], searchParams: URLSearchParams): BusinessViewRow[] {
|
||
const date = stringValue(searchParams.get('date'));
|
||
return filterBusinessRows(rows, searchParams)
|
||
.filter((row) => !date || stringValue(row.date) === date);
|
||
}
|
||
|
||
function filterBusinessRows(rows: BusinessViewRow[], searchParams: URLSearchParams): BusinessViewRow[] {
|
||
const entityId = stringValue(searchParams.get('entity_id'));
|
||
const remoteId = stringValue(searchParams.get('remote_id'));
|
||
const status = stringValue(searchParams.get('status'));
|
||
const syncStatus = stringValue(searchParams.get('sync_status'));
|
||
const updatedFrom = stringValue(searchParams.get('updated_from'));
|
||
const updatedTo = stringValue(searchParams.get('updated_to'));
|
||
return rows
|
||
.filter((row) => !entityId || businessRowEntityIds(row).includes(entityId))
|
||
.filter((row) => !remoteId || stringValue(row.remote_id) === remoteId)
|
||
.filter((row) => !status || stringValue(row.status) === status)
|
||
.filter((row) => !syncStatus || stringValue(row.sync_status) === syncStatus)
|
||
.filter((row) => {
|
||
const timestamp = businessRowUpdatedAt(row);
|
||
if (updatedFrom && (!timestamp || timestamp < updatedFrom)) return false;
|
||
if (updatedTo && (!timestamp || timestamp > updatedTo)) return false;
|
||
return true;
|
||
});
|
||
}
|
||
|
||
function paginateBusinessRows(rows: BusinessViewRow[], searchParams: URLSearchParams): { items: BusinessViewRow[]; page_no: number; page_size: number; total: number } {
|
||
const pageNo = Math.max(1, Math.floor(numberValue(searchParams.get('page_no')) ?? 1));
|
||
const pageSize = Math.max(1, Math.min(Math.floor(numberValue(searchParams.get('page_size')) ?? 20), 100));
|
||
const start = (pageNo - 1) * pageSize;
|
||
return {
|
||
items: rows.slice(start, start + pageSize),
|
||
page_no: pageNo,
|
||
page_size: pageSize,
|
||
total: rows.length,
|
||
};
|
||
}
|
||
|
||
function businessEntityFromRefs(refs: Record<string, unknown>): { entity_type: string; entity_id: string | null } {
|
||
const runId = stringValue(refs.run_id);
|
||
if (runId) return { entity_type: 'run', entity_id: runId };
|
||
const taskId = stringValue(refs.task_id);
|
||
if (taskId) return { entity_type: 'task', entity_id: taskId };
|
||
const planId = stringValue(refs.plan_id);
|
||
if (planId) return { entity_type: 'plan', entity_id: planId };
|
||
return {
|
||
entity_type: stringValue(refs.fallback_type) || 'record',
|
||
entity_id: stringValue(refs.fallback_id) || null,
|
||
};
|
||
}
|
||
|
||
function businessRowEntityIds(row: BusinessViewRow): string[] {
|
||
return uniqueStrings([
|
||
row.entity_id,
|
||
row.plan_id,
|
||
row.task_id,
|
||
row.run_id,
|
||
row.event_id,
|
||
row.history_id,
|
||
row.step_id,
|
||
row.node_id,
|
||
row.artifact_id,
|
||
row.approval_id,
|
||
row.notification_id,
|
||
row.report_id,
|
||
]);
|
||
}
|
||
|
||
function businessRowUpdatedAt(row: BusinessViewRow): string {
|
||
return stringValue(row.updated_at)
|
||
|| stringValue(row.finished_at)
|
||
|| stringValue(row.started_at)
|
||
|| stringValue(row.occurred_at)
|
||
|| stringValue(row.latest_event_at)
|
||
|| stringValue(row.created_at);
|
||
}
|
||
|
||
function durationMs(startedAt?: string | null, finishedAt?: string | null): number | null {
|
||
if (!startedAt || !finishedAt) return null;
|
||
const started = Date.parse(startedAt);
|
||
const finished = Date.parse(finishedAt);
|
||
if (!Number.isFinite(started) || !Number.isFinite(finished) || finished < started) return null;
|
||
return finished - started;
|
||
}
|
||
|
||
function auditEventFromRuntimeEvent(event: QimingclawEventRecord): Record<string, unknown> {
|
||
const payload = asRecord(event.payload) ?? {};
|
||
const category = event.kind.startsWith('governance_')
|
||
? 'governance'
|
||
: event.kind === 'route_decision'
|
||
? 'route'
|
||
: event.kind === 'approval_decision'
|
||
? 'approval'
|
||
: 'runtime';
|
||
const entityType = event.runId ? 'run' : event.taskId ? 'task' : event.planId ? 'plan' : 'event';
|
||
return {
|
||
audit_id: event.id,
|
||
category,
|
||
action: event.kind,
|
||
level: /fail|error|reject|cancel/i.test(`${event.kind} ${event.message}`) ? 'error' : 'info',
|
||
message: event.message || event.kind,
|
||
actor: stringValue(payload.actor) || stringValue(payload.source) || 'qimingclaw-runtime',
|
||
entity_type: entityType,
|
||
entity_id: event.runId ?? event.taskId ?? event.planId ?? event.id,
|
||
occurred_at: event.occurredAt,
|
||
payload,
|
||
};
|
||
}
|
||
|
||
function auditEventsFromArtifact(artifact: ArtifactEntry): Array<Record<string, unknown>> {
|
||
const deliveryStatus = stringValue(artifact.delivery_status);
|
||
if (!deliveryStatus) return [];
|
||
return [{
|
||
audit_id: `artifact_delivery:${artifact.artifact_id ?? artifact.subject_id}`,
|
||
category: 'artifact',
|
||
action: stringValue(artifact.delivery_stage) || 'artifact_delivery',
|
||
level: deliveryStatus === 'failed' || deliveryStatus === 'error' ? 'error' : 'info',
|
||
message: `${artifact.name || artifact.kind || 'Artifact'}：${deliveryStatus}`,
|
||
actor: stringValue(artifact.source_tool) || 'qimingclaw-file-server',
|
||
entity_type: 'artifact',
|
||
entity_id: artifact.artifact_id ?? artifact.subject_id,
|
||
occurred_at: stringValue(artifact.created_at) || new Date().toISOString(),
|
||
payload: artifact,
|
||
}];
|
||
}
|
||
|
||
function buildCanonicalEvents(
|
||
snapshot: QimingclawSnapshot | null,
|
||
tasks: DebugTask[],
|
||
runs: DebugRun[],
|
||
): CanonicalEvent[] {
|
||
const runtimeCanonicalEvents = runtimeEvents(snapshot).map((event) => ({
|
||
event_id: event.id,
|
||
aggregate_type: event.runId ? 'run' : event.taskId ? 'task' : 'plan',
|
||
aggregate_id: event.runId ?? event.taskId ?? event.planId ?? event.id,
|
||
event_type: event.kind,
|
||
kind: event.kind,
|
||
message: event.message,
|
||
occurred_at: event.occurredAt,
|
||
timestamp: event.occurredAt,
|
||
plan_id: event.planId ?? null,
|
||
task_id: event.taskId ?? null,
|
||
}));
|
||
|
||
const runEvents = runs.flatMap((run) => (run.events ?? []).map((event) => ({
|
||
event_id: event.event_id ?? `${run.run_id}:${event.kind ?? 'event'}:${event.occurred_at ?? run.created_at}`,
|
||
aggregate_type: 'run',
|
||
aggregate_id: run.run_id,
|
||
event_type: event.kind ?? run.lifecycle,
|
||
kind: event.kind ?? run.lifecycle,
|
||
message: event.message ?? run.lifecycle,
|
||
occurred_at: event.occurred_at ?? run.completed_at ?? run.created_at,
|
||
timestamp: event.occurred_at ?? run.completed_at ?? run.created_at,
|
||
plan_id: run.plan_id ?? null,
|
||
task_id: run.task_id || null,
|
||
})));
|
||
|
||
const taskEvents = tasks.map((task) => ({
|
||
event_id: `task-status-${task.task_id}`,
|
||
aggregate_type: 'task',
|
||
aggregate_id: task.task_id,
|
||
event_type: 'task_status',
|
||
kind: task.status,
|
||
message: `${task.title}：${taskStatusLabel(task.status)}`,
|
||
occurred_at: task.updated_at ?? task.created_at,
|
||
timestamp: task.updated_at ?? task.created_at,
|
||
plan_id: task.plan_id ?? null,
|
||
task_id: task.task_id,
|
||
}));
|
||
|
||
const syncEvents = (snapshot?.sync?.recentFailures ?? []).map((failure) => ({
|
||
event_id: `digital-sync-failure-${failure.id}`,
|
||
aggregate_type: 'sync_outbox',
|
||
aggregate_id: failure.id,
|
||
event_type: 'digital_sync_failed',
|
||
kind: 'digital_sync_failed',
|
||
message: syncFailureLine(failure),
|
||
occurred_at: failure.lastAttemptAt ?? failure.updatedAt ?? failure.createdAt,
|
||
timestamp: failure.lastAttemptAt ?? failure.updatedAt ?? failure.createdAt,
|
||
plan_id: null,
|
||
task_id: null,
|
||
}));
|
||
|
||
return dedupeCanonicalEvents([
|
||
...runtimeCanonicalEvents,
|
||
...runEvents,
|
||
...taskEvents,
|
||
...syncEvents,
|
||
]).sort((left, right) => (right.occurred_at ?? '').localeCompare(left.occurred_at ?? ''));
|
||
}
|
||
|
||
function dedupeCanonicalEvents(events: CanonicalEvent[]): CanonicalEvent[] {
|
||
const seen = new Set<string>();
|
||
return events.filter((event) => {
|
||
if (!event.event_id || seen.has(event.event_id)) return false;
|
||
seen.add(event.event_id);
|
||
return true;
|
||
});
|
||
}
|
||
|
||
function buildApprovals(snapshot: QimingclawSnapshot | null): ApprovalEntry[] {
|
||
const runtimeApprovalEntries = runtimeApprovals(snapshot).map((approval) => ({
|
||
approval_id: approval.id,
|
||
task_id: approval.taskId ?? '',
|
||
status: approval.status,
|
||
created_at: approval.createdAt,
|
||
plan_id: approval.planId ?? null,
|
||
run_id: approval.runId ?? null,
|
||
title: approval.title,
|
||
reversible: approval.status === 'pending',
|
||
source: 'qimingclaw-runtime',
|
||
sync_status: approval.syncStatus,
|
||
sync_error: approval.syncError,
|
||
payload: approval.payload,
|
||
}));
|
||
const failures = snapshot?.sync?.recentFailures ?? [];
|
||
const syncReviewEntries = failures
|
||
.filter((failure) => failure.dueForRetry === false || /credential|auth|token|unauthor/i.test(failure.error ?? ''))
|
||
.slice(0, 20)
|
||
.map((failure) => ({
|
||
approval_id: `sync-review-${failure.id}`,
|
||
task_id: failure.entityId,
|
||
status: 'pending',
|
||
created_at: failure.createdAt,
|
||
title: `同步异常待处理：${failure.entityType}/${failure.entityId}`,
|
||
reversible: false,
|
||
source: 'qimingclaw-sync',
|
||
error: failure.error,
|
||
}));
|
||
return [...runtimeApprovalEntries, ...syncReviewEntries];
|
||
}
|
||
|
||
function buildApprovalTimeline(approvalId: string, snapshot: QimingclawSnapshot | null): ApprovalTimelineResponse {
|
||
const approval = buildApprovals(snapshot).find((candidate) => stringValue(candidate.approval_id) === approvalId) ?? null;
|
||
const runtimeApproval = runtimeApprovals(snapshot).find((candidate) => candidate.id === approvalId) ?? null;
|
||
const approvalPayload = asRecord(approval?.payload ?? runtimeApproval?.payload);
|
||
const approvalAcpPermission = acpPermissionFromPayload(approvalPayload);
|
||
const refs = {
|
||
approvalId,
|
||
planId: stringValue(approval?.plan_id) || runtimeApproval?.planId || '',
|
||
taskId: stringValue(approval?.task_id) || runtimeApproval?.taskId || '',
|
||
runId: stringValue(approval?.run_id) || runtimeApproval?.runId || '',
|
||
permissionId: approvalAcpPermission.permissionId,
|
||
sessionId: approvalAcpPermission.sessionId,
|
||
};
|
||
const approvalCreatedAt = stringValue(approval?.created_at) || runtimeApproval?.createdAt || runtimeApproval?.updatedAt || '';
|
||
const entries: ApprovalTimelineResponse['events'] = [];
|
||
|
||
if (approval || runtimeApproval) {
|
||
const title = stringValue(approval?.title) || runtimeApproval?.title || '待确认事项';
|
||
const status = stringValue(approval?.status) || runtimeApproval?.status || 'pending';
|
||
entries.push({
|
||
event_id: `${approvalId}:approval_record`,
|
||
kind: 'approval_record',
|
||
status,
|
||
message: `审批记录：${title} -> ${status}`,
|
||
occurred_at: approvalCreatedAt || new Date().toISOString(),
|
||
payload: approvalPayload,
|
||
source_type: 'approval',
|
||
});
|
||
}
|
||
|
||
for (const event of runtimeEvents(snapshot)) {
|
||
if (!isApprovalTimelineEvent(event, refs)) continue;
|
||
const payload = asRecord(event.payload);
|
||
entries.push({
|
||
event_id: event.id,
|
||
kind: event.kind,
|
||
status: approvalTimelineEventStatus(event, payload),
|
||
message: event.message || event.kind,
|
||
occurred_at: event.occurredAt,
|
||
payload,
|
||
source_type: stringValue(payload?.source) || 'runtime_event',
|
||
});
|
||
}
|
||
|
||
return {
|
||
approval_id: approvalId,
|
||
approval,
|
||
events: dedupeApprovalTimelineEvents(entries)
|
||
.sort((left, right) => left.occurred_at.localeCompare(right.occurred_at) || left.event_id.localeCompare(right.event_id)),
|
||
};
|
||
}
|
||
|
||
function acpPermissionFromPayload(payload: Record<string, unknown> | null): { permissionId: string; sessionId: string } {
|
||
const nested = asRecord(payload?.acpPermission) ?? asRecord(payload?.acp_permission) ?? asRecord(payload?.permission);
|
||
return {
|
||
permissionId: stringValue(nested?.permission_id) || stringValue(nested?.permissionId) || stringValue(payload?.permission_id) || stringValue(payload?.permissionId),
|
||
sessionId: stringValue(nested?.session_id) || stringValue(nested?.sessionId) || stringValue(payload?.session_id) || stringValue(payload?.sessionId),
|
||
};
|
||
}
|
||
|
||
function isApprovalTimelineEvent(
|
||
event: QimingclawEventRecord,
|
||
refs: { approvalId: string; planId: string; taskId: string; runId: string; permissionId: string; sessionId: string },
|
||
): boolean {
|
||
const payload = asRecord(event.payload);
|
||
const payloadApprovalId = stringValue(payload?.approvalId)
|
||
|| stringValue(payload?.approval_id)
|
||
|| stringValue(payload?.decision_id)
|
||
|| stringValue(payload?.decisionId);
|
||
if (payloadApprovalId === refs.approvalId) return true;
|
||
if (event.id.startsWith(`${refs.approvalId}:`)) return true;
|
||
|
||
const acpPermission = acpPermissionFromPayload(payload);
|
||
if (refs.permissionId && acpPermission.permissionId === refs.permissionId) return true;
|
||
if (refs.sessionId && acpPermission.sessionId === refs.sessionId) return true;
|
||
|
||
const approvalLikeKind = event.kind.includes('approval') || event.kind.includes('permission');
|
||
if (!approvalLikeKind) return false;
|
||
if (refs.runId && event.runId === refs.runId) return true;
|
||
if (refs.taskId && event.taskId === refs.taskId) return true;
|
||
if (refs.planId && event.planId === refs.planId) return true;
|
||
return false;
|
||
}
|
||
|
||
function approvalTimelineEventStatus(event: QimingclawEventRecord, payload: Record<string, unknown> | null): string | null {
|
||
return stringValue(payload?.nextStatus)
|
||
|| stringValue(payload?.next_status)
|
||
|| stringValue(payload?.status)
|
||
|| stringValue(payload?.decision)
|
||
|| (event.kind === 'approval_decision' ? 'completed' : null);
|
||
}
|
||
|
||
function dedupeApprovalTimelineEvents(events: ApprovalTimelineResponse['events']): ApprovalTimelineResponse['events'] {
|
||
const seen = new Set<string>();
|
||
return events.filter((event) => {
|
||
if (seen.has(event.event_id)) return false;
|
||
seen.add(event.event_id);
|
||
return true;
|
||
});
|
||
}
|
||
|
||
function notificationAdapterState(snapshot: QimingclawSnapshot | null): AdapterState {
|
||
return snapshot?.uiState ? normalizeAdapterState(snapshot.uiState) : readState();
|
||
}
|
||
|
||
function buildNotificationsResponse(status: string | null, snapshot: QimingclawSnapshot | null): { notifications: UserNotification[] } {
|
||
const notifications = buildNotifications(snapshot, notificationAdapterState(snapshot));
|
||
const normalizedStatus = (status || 'all').toLowerCase();
|
||
if (normalizedStatus === 'all') {
|
||
return { notifications: notifications.filter((notification) => notification.status !== 'dismissed') };
|
||
}
|
||
return { notifications: notifications.filter((notification) => notification.status === normalizedStatus) };
|
||
}
|
||
|
||
function buildNotifications(snapshot: QimingclawSnapshot | null, state: AdapterState): UserNotification[] {
|
||
return buildNotificationCandidates(snapshot, state)
|
||
.filter((notification) => notificationMatchesPreferences(notification, state.notificationPreferences));
|
||
}
|
||
|
||
function buildNotificationCandidates(snapshot: QimingclawSnapshot | null, state: AdapterState): UserNotification[] {
|
||
const notifications = dedupeNotifications([
|
||
...approvalNotifications(snapshot),
|
||
...approvalActionNotifications(snapshot),
|
||
...syncFailureNotifications(snapshot),
|
||
...managedServiceNotifications(snapshot),
|
||
...planStepDispatchNotifications(snapshot),
|
||
...routeDecisionNotifications(snapshot),
|
||
...diagnosticNotifications(snapshot),
|
||
...auditNotifications(snapshot),
|
||
...taskNotifications(snapshot),
|
||
]);
|
||
const overlays = state.notificationStateById ?? {};
|
||
return notifications
|
||
.map((notification) => applyNotificationOverlay(notification, overlays[notification.notification_id]))
|
||
.sort((left, right) => right.created_at.localeCompare(left.created_at) || right.notification_id.localeCompare(left.notification_id));
|
||
}
|
||
|
||
function defaultNotificationPreferences(): NotificationPreferences {
|
||
return {
|
||
enabled: true,
|
||
muted_kinds: [],
|
||
muted_levels: [],
|
||
updated_at: null,
|
||
};
|
||
}
|
||
|
||
function defaultApprovalSubscriptionPreferences(): ApprovalSubscriptionPreferences {
|
||
return {
|
||
enabled: true,
|
||
subscribed_actions: [...APPROVAL_SUBSCRIPTION_ACTIONS],
|
||
subscribed_risk_levels: ['high', 'critical'],
|
||
notify_on_timeout: true,
|
||
updated_at: null,
|
||
};
|
||
}
|
||
|
||
function defaultPlanStepDispatchPolicy(): PlanStepDispatchPolicy {
|
||
return {
|
||
enabled: true,
|
||
max_per_sweep: 3,
|
||
auto_dispatch_ready_steps: true,
|
||
updated_at: null,
|
||
};
|
||
}
|
||
|
||
function approvalSubscriptionPreferences(state: Partial<AdapterState> | null | undefined): ApprovalSubscriptionPreferences {
|
||
const stored = state?.approvalSubscriptionPreferences;
|
||
const fallback = defaultApprovalSubscriptionPreferences();
|
||
if (!stored || typeof stored !== 'object') return fallback;
|
||
const actions = Array.isArray(stored.subscribed_actions)
|
||
? stored.subscribed_actions.filter((action): action is ApprovalSubscriptionPreferences['subscribed_actions'][number] => APPROVAL_SUBSCRIPTION_ACTIONS.includes(action as ApprovalSubscriptionPreferences['subscribed_actions'][number]))
|
||
: fallback.subscribed_actions;
|
||
const riskLevels = Array.isArray(stored.subscribed_risk_levels)
|
||
? stored.subscribed_risk_levels.filter((level): level is ApprovalSubscriptionPreferences['subscribed_risk_levels'][number] => APPROVAL_SUBSCRIPTION_RISK_LEVELS.includes(level as ApprovalSubscriptionPreferences['subscribed_risk_levels'][number]))
|
||
: fallback.subscribed_risk_levels;
|
||
return {
|
||
enabled: stored.enabled !== false,
|
||
subscribed_actions: [...new Set(actions)],
|
||
subscribed_risk_levels: [...new Set(riskLevels)],
|
||
notify_on_timeout: stored.notify_on_timeout !== false,
|
||
updated_at: typeof stored.updated_at === 'string' ? stored.updated_at : fallback.updated_at,
|
||
};
|
||
}
|
||
|
||
function planStepDispatchPolicy(state: Partial<AdapterState> | null | undefined): PlanStepDispatchPolicy {
|
||
const stored = state?.planStepDispatchPolicy;
|
||
const fallback = defaultPlanStepDispatchPolicy();
|
||
if (!stored || typeof stored !== 'object') return fallback;
|
||
const maxPerSweep = Number(stored.max_per_sweep);
|
||
return {
|
||
enabled: stored.enabled !== false,
|
||
max_per_sweep: Number.isFinite(maxPerSweep) ? Math.max(1, Math.min(Math.floor(maxPerSweep), 10)) : fallback.max_per_sweep,
|
||
auto_dispatch_ready_steps: stored.auto_dispatch_ready_steps !== false,
|
||
updated_at: typeof stored.updated_at === 'string' ? stored.updated_at : fallback.updated_at,
|
||
};
|
||
}
|
||
|
||
function notificationPreferences(state: Partial<AdapterState> | null | undefined): NotificationPreferences {
|
||
const stored = state?.notificationPreferences;
|
||
const fallback = defaultNotificationPreferences();
|
||
if (!stored || typeof stored !== 'object') return fallback;
|
||
const mutedKinds = Array.isArray(stored.muted_kinds)
|
||
? stored.muted_kinds.filter((kind): kind is UserNotification['kind'] => NOTIFICATION_KINDS.includes(kind as UserNotification['kind']))
|
||
: [];
|
||
const mutedLevels = Array.isArray(stored.muted_levels)
|
||
? stored.muted_levels.filter((level): level is UserNotification['level'] => NOTIFICATION_LEVELS.includes(level as UserNotification['level']))
|
||
: [];
|
||
return {
|
||
enabled: stored.enabled !== false,
|
||
muted_kinds: [...new Set(mutedKinds)],
|
||
muted_levels: [...new Set(mutedLevels)],
|
||
updated_at: typeof stored.updated_at === 'string' ? stored.updated_at : fallback.updated_at,
|
||
};
|
||
}
|
||
|
||
function notificationMatchesPreferences(
|
||
notification: UserNotification,
|
||
preferences: NotificationPreferences | undefined,
|
||
): boolean {
|
||
const normalized = notificationPreferences({ notificationPreferences: preferences });
|
||
if (!normalized.enabled) return false;
|
||
if (normalized.muted_levels.includes(notification.level)) return false;
|
||
return !normalized.muted_kinds.includes(notification.kind);
|
||
}
|
||
|
||
async function handleNotificationPreferencesPatch(
|
||
patch: Partial<NotificationPreferences>,
|
||
snapshot: QimingclawSnapshot | null,
|
||
): Promise<NotificationPreferences> {
|
||
const state = snapshot?.uiState ?? await readBridgeUiState() ?? readState();
|
||
const current = notificationPreferences(state);
|
||
const next = notificationPreferences({
|
||
notificationPreferences: {
|
||
...current,
|
||
...patch,
|
||
updated_at: new Date().toISOString(),
|
||
},
|
||
});
|
||
await saveState(
|
||
{
|
||
...normalizeAdapterState(state),
|
||
notificationPreferences: next,
|
||
},
|
||
'update_notification_preferences',
|
||
undefined,
|
||
{ notification_preferences: next },
|
||
);
|
||
return next;
|
||
}
|
||
|
||
async function handleApprovalSubscriptionPreferencesPatch(
|
||
patch: Partial<ApprovalSubscriptionPreferences>,
|
||
snapshot: QimingclawSnapshot | null,
|
||
): Promise<ApprovalSubscriptionPreferences> {
|
||
const state = snapshot?.uiState ?? await readBridgeUiState() ?? readState();
|
||
const current = approvalSubscriptionPreferences(state);
|
||
const next = approvalSubscriptionPreferences({
|
||
approvalSubscriptionPreferences: {
|
||
...current,
|
||
...patch,
|
||
updated_at: new Date().toISOString(),
|
||
},
|
||
});
|
||
await saveState(
|
||
{
|
||
...normalizeAdapterState(state),
|
||
approvalSubscriptionPreferences: next,
|
||
},
|
||
'update_approval_subscriptions',
|
||
undefined,
|
||
{ approval_subscriptions: next },
|
||
);
|
||
return next;
|
||
}
|
||
|
||
async function handlePlanStepDispatchPolicyPatch(
|
||
patch: Partial<PlanStepDispatchPolicy>,
|
||
snapshot: QimingclawSnapshot | null,
|
||
): Promise<PlanStepDispatchPolicy> {
|
||
const state = snapshot?.uiState ?? await readBridgeUiState() ?? readState();
|
||
const current = planStepDispatchPolicy(state);
|
||
const next = planStepDispatchPolicy({
|
||
planStepDispatchPolicy: {
|
||
...current,
|
||
...patch,
|
||
updated_at: new Date().toISOString(),
|
||
},
|
||
});
|
||
await saveState(
|
||
{
|
||
...normalizeAdapterState(state),
|
||
planStepDispatchPolicy: next,
|
||
},
|
||
'update_plan_step_dispatch_policy',
|
||
undefined,
|
||
{ plan_step_dispatch_policy: next },
|
||
);
|
||
return next;
|
||
}
|
||
|
||
function approvalNotifications(snapshot: QimingclawSnapshot | null): UserNotification[] {
|
||
const summaries = new Map(businessApprovalRows(snapshot).map((approval) => [stringValue(approval.approval_id), approval]));
|
||
return buildApprovals(snapshot)
|
||
.filter((approval) => stringValue(approval.source) === 'qimingclaw-runtime')
|
||
.map((approval) => {
|
||
const status = stringValue(approval.status) || 'pending';
|
||
const open = isDecisionOpenStatus(status);
|
||
const summary = summaries.get(stringValue(approval.approval_id));
|
||
const slaStatus = stringValue(summary?.sla_status);
|
||
const riskLevel = stringValue(summary?.risk_level);
|
||
const warn = open && (slaStatus === 'timeout' || riskLevel === 'high');
|
||
return {
|
||
notification_id: `approval:${stringValue(approval.approval_id)}`,
|
||
plan_id: stringValue(approval.plan_id),
|
||
task_id: stringValue(approval.task_id),
|
||
kind: open ? 'need_approval' : 'confirmation_resolved',
|
||
title: warn ? '审批需要关注' : open ? '审批待处理' : '审批已处理',
|
||
body: stringValue(approval.title) || '待确认事项',
|
||
level: warn ? 'warn' : open ? 'action' : 'info',
|
||
status: open ? 'unread' : 'resolved',
|
||
correlation_id: stringValue(approval.approval_id),
|
||
created_at: stringValue(approval.created_at) || new Date().toISOString(),
|
||
} satisfies UserNotification;
|
||
});
|
||
}
|
||
|
||
function approvalActionNotifications(snapshot: QimingclawSnapshot | null): UserNotification[] {
|
||
return approvalActionRows(snapshot)
|
||
.filter((action) => stringValue(action.kind) === 'approval_action_recorded')
|
||
.filter((action) => ['delegate', 'mark_timeout', 'mark_risk'].includes(stringValue(action.action)))
|
||
.map((action) => {
|
||
const actionKind = stringValue(action.action);
|
||
const approvalId = stringValue(action.approval_id);
|
||
const isTimeout = actionKind === 'mark_timeout';
|
||
const isRisk = actionKind === 'mark_risk';
|
||
return {
|
||
notification_id: `approval-action:${approvalId}:${actionKind}:${slugifyIdPart(stringValue(action.occurred_at))}`,
|
||
plan_id: stringValue(action.plan_id),
|
||
task_id: stringValue(action.task_id),
|
||
kind: 'need_approval',
|
||
title: isTimeout ? '审批已超时' : isRisk ? '审批已标记风险' : '审批已转交',
|
||
body: stringValue(action.message) || approvalId,
|
||
level: isTimeout || isRisk ? 'warn' : 'action',
|
||
status: 'unread',
|
||
correlation_id: approvalId,
|
||
created_at: stringValue(action.occurred_at) || new Date().toISOString(),
|
||
} satisfies UserNotification;
|
||
});
|
||
}
|
||
|
||
function syncFailureNotifications(snapshot: QimingclawSnapshot | null): UserNotification[] {
|
||
return (snapshot?.sync?.recentFailures ?? []).map((failure) => ({
|
||
notification_id: `sync_failure:${failure.id}`,
|
||
plan_id: '',
|
||
task_id: failure.entityId,
|
||
kind: 'task_failed',
|
||
title: `同步失败：${failure.entityType}`,
|
||
body: syncFailureLine(failure),
|
||
level: failure.dueForRetry === false ? 'error' : 'warn',
|
||
status: 'unread',
|
||
correlation_id: failure.id,
|
||
created_at: failure.lastAttemptAt ?? failure.updatedAt ?? failure.createdAt,
|
||
}));
|
||
}
|
||
|
||
function managedServiceNotifications(snapshot: QimingclawSnapshot | null): UserNotification[] {
|
||
return buildManagedServices(snapshot)
|
||
.filter((service) => service.requires_human_action || service.status === 'degraded' || service.status === 'stopped')
|
||
.map((service) => ({
|
||
notification_id: `service:${service.service_id}`,
|
||
plan_id: '',
|
||
task_id: service.dependent_tasks?.[0] ?? '',
|
||
kind: 'need_input',
|
||
title: `服务需要处理：${service.name}`,
|
||
body: service.error || `${service.name} 当前状态：${service.status_label || service.status}`,
|
||
level: service.status === 'stopped' ? 'error' : 'warn',
|
||
status: 'unread',
|
||
correlation_id: service.service_id,
|
||
created_at: service.last_seen_at || new Date().toISOString(),
|
||
}));
|
||
}
|
||
|
||
function taskNotifications(snapshot: QimingclawSnapshot | null): UserNotification[] {
|
||
return runtimeTasks(snapshot).flatMap((task) => {
|
||
const normalized = task.status.toLowerCase();
|
||
const success = ['completed', 'succeeded', 'success', 'done'].includes(normalized);
|
||
const failed = ['failed', 'error', 'rejected', 'cancelled', 'skipped'].includes(normalized);
|
||
if (!success && !failed) return [];
|
||
const timestamp = task.updatedAt || task.createdAt || new Date().toISOString();
|
||
return [{
|
||
notification_id: `task:${task.id}:${slugifyIdPart(timestamp)}`,
|
||
plan_id: task.planId ?? '',
|
||
task_id: task.id,
|
||
kind: success ? 'task_finished' : 'task_failed',
|
||
title: success ? '任务已完成' : '任务需要关注',
|
||
body: `${task.title}：${taskStatusLabel(task.status)}`,
|
||
level: success ? 'info' : 'error',
|
||
status: 'unread',
|
||
correlation_id: task.id,
|
||
created_at: timestamp,
|
||
} satisfies UserNotification];
|
||
});
|
||
}
|
||
|
||
function planStepDispatchNotifications(snapshot: QimingclawSnapshot | null): UserNotification[] {
|
||
return runtimeEvents(snapshot)
|
||
.filter((event) => event.kind === 'plan_step_dispatch_failed')
|
||
.map((event) => {
|
||
const payload = asRecord(event.payload) ?? {};
|
||
const stepId = stringValue(payload.step_id) || event.id;
|
||
const reason = stringValue(payload.reason);
|
||
return {
|
||
notification_id: `plan-step-dispatch:${stepId}:${slugifyIdPart(event.occurredAt)}`,
|
||
plan_id: event.planId ?? stringValue(payload.plan_id),
|
||
task_id: event.taskId ?? stringValue(payload.task_id),
|
||
kind: 'task_failed',
|
||
title: 'Ready 步骤派发失败',
|
||
body: reason ? `${stepId}：${reason}` : (event.message || stepId),
|
||
level: 'error',
|
||
status: 'unread',
|
||
correlation_id: stepId,
|
||
created_at: event.occurredAt,
|
||
} satisfies UserNotification;
|
||
});
|
||
}
|
||
|
||
function routeDecisionNotifications(snapshot: QimingclawSnapshot | null): UserNotification[] {
|
||
return routeDecisionRows(snapshot)
|
||
.filter((row) => ['warn', 'error', 'action'].includes(stringValue(row.attention_level)))
|
||
.map((row) => {
|
||
const attentionLevel = stringValue(row.attention_level);
|
||
const routeId = stringValue(row.route_decision_id) || stringValue(row.event_id);
|
||
const commandId = stringValue(row.created_command_id);
|
||
const reasonCodes = arrayValue(row.reason_codes).map(stringValue).filter(Boolean).join(' / ');
|
||
return {
|
||
notification_id: `route-decision:${routeId}:${slugifyIdPart(stringValue(row.recorded_at))}`,
|
||
plan_id: stringValue(asRecord(row.context_refs)?.plan_id),
|
||
task_id: stringValue(asRecord(row.context_refs)?.task_id),
|
||
kind: attentionLevel === 'action' ? 'task_progress' : 'task_failed',
|
||
title: attentionLevel === 'action' ? '入口路由已映射' : '入口路由需要关注',
|
||
body: commandId
|
||
? `${row.route_kind} / ${row.intent_kind} -> ${commandId}`
|
||
: `${row.route_kind} / ${row.intent_kind}${reasonCodes ? `：${reasonCodes}` : ''}`,
|
||
level: attentionLevel === 'error' ? 'error' : attentionLevel === 'warn' ? 'warn' : 'action',
|
||
status: 'unread',
|
||
correlation_id: routeId,
|
||
created_at: stringValue(row.recorded_at) || new Date().toISOString(),
|
||
} satisfies UserNotification;
|
||
});
|
||
}
|
||
|
||
function diagnosticNotifications(snapshot: QimingclawSnapshot | null): UserNotification[] {
|
||
return buildDoctor(snapshot).results
|
||
.filter((result) => result.severity === 'error' || result.severity === 'warn')
|
||
.map((result) => {
|
||
const level = result.severity === 'error' ? 'error' : 'warn';
|
||
const diagnosticId = stringValue(result.id) || `${stringValue(result.category) || 'diagnostic'}:${level}`;
|
||
return {
|
||
notification_id: `diagnostic:${diagnosticId}`,
|
||
plan_id: '',
|
||
task_id: '',
|
||
kind: level === 'error' ? 'task_failed' : 'need_input',
|
||
title: level === 'error' ? '诊断发现异常' : '诊断需要关注',
|
||
body: result.message,
|
||
level,
|
||
status: 'unread',
|
||
correlation_id: diagnosticId,
|
||
created_at: result.created_at ?? new Date().toISOString(),
|
||
} satisfies UserNotification;
|
||
});
|
||
}
|
||
|
||
function auditNotifications(snapshot: QimingclawSnapshot | null): UserNotification[] {
|
||
return auditRows(snapshot)
|
||
.filter((event) => ['error', 'warn'].includes(stringValue(event.level)))
|
||
.map((event) => {
|
||
const level = stringValue(event.level) === 'error' ? 'error' : 'warn';
|
||
const auditId = stringValue(event.audit_id) || stringValue(event.entity_id) || 'audit';
|
||
return {
|
||
notification_id: `audit:${auditId}`,
|
||
plan_id: stringValue(event.plan_id),
|
||
task_id: stringValue(event.task_id) || (stringValue(event.entity_type) === 'task' ? stringValue(event.entity_id) : ''),
|
||
kind: level === 'error' ? 'task_failed' : 'need_input',
|
||
title: level === 'error' ? '审计发现异常' : '审计需要关注',
|
||
body: stringValue(event.message) || stringValue(event.action) || auditId,
|
||
level,
|
||
status: 'unread',
|
||
correlation_id: auditId,
|
||
created_at: stringValue(event.occurred_at) || new Date().toISOString(),
|
||
} satisfies UserNotification;
|
||
});
|
||
}
|
||
|
||
function applyNotificationOverlay(notification: UserNotification, overlay?: NotificationState): UserNotification {
|
||
if (!overlay) return notification;
|
||
return {
|
||
...notification,
|
||
status: overlay.status ?? notification.status,
|
||
read_at: overlay.read_at ?? notification.read_at ?? null,
|
||
dismissed_at: overlay.dismissed_at ?? notification.dismissed_at ?? null,
|
||
reply: overlay.reply ?? notification.reply ?? null,
|
||
replied_at: overlay.replied_at ?? notification.replied_at ?? null,
|
||
};
|
||
}
|
||
|
||
function dedupeNotifications(notifications: UserNotification[]): UserNotification[] {
|
||
const seen = new Set<string>();
|
||
return notifications.filter((notification) => {
|
||
if (!notification.notification_id || seen.has(notification.notification_id)) return false;
|
||
seen.add(notification.notification_id);
|
||
return true;
|
||
});
|
||
}
|
||
|
||
async function handleNotificationAction(
|
||
notificationId: string,
|
||
action: 'read' | 'dismiss' | 'reply',
|
||
body: Record<string, unknown>,
|
||
snapshot: QimingclawSnapshot | null,
|
||
): Promise<{ ok: boolean; task_id?: string; status?: string; task_input_recorded?: boolean; governance_command_id?: string; governance_event_id?: string }> {
|
||
const state = snapshot?.uiState ?? await readBridgeUiState() ?? readState();
|
||
const current = buildNotifications(snapshot, state).find((notification) => notification.notification_id === notificationId);
|
||
const now = new Date().toISOString();
|
||
const previousOverlay = state.notificationStateById?.[notificationId];
|
||
const alreadyReplied = Boolean(previousOverlay?.replied_at);
|
||
const overlay: NotificationState = { ...(previousOverlay ?? {}) };
|
||
let replyContent = '';
|
||
if (action === 'read') {
|
||
overlay.status = current?.status === 'resolved' ? 'resolved' : 'read';
|
||
overlay.read_at = overlay.read_at ?? now;
|
||
} else if (action === 'dismiss') {
|
||
overlay.status = 'dismissed';
|
||
overlay.dismissed_at = now;
|
||
} else {
|
||
overlay.status = current?.status === 'resolved' ? 'resolved' : 'read';
|
||
overlay.read_at = overlay.read_at ?? now;
|
||
replyContent = stringValue(body.content ?? body.reply ?? body.message);
|
||
overlay.reply = replyContent;
|
||
overlay.replied_at = now;
|
||
}
|
||
const nextState: AdapterState = {
|
||
...state,
|
||
notificationStateById: {
|
||
...(state.notificationStateById ?? {}),
|
||
[notificationId]: overlay,
|
||
},
|
||
};
|
||
await saveState(nextState, `notification_${action}`, undefined, { notification_id: notificationId, action });
|
||
const taskInput = action === 'reply' && current?.kind === 'need_input' && current.task_id && replyContent && !alreadyReplied
|
||
? await recordNotificationTaskInput(current, replyContent, snapshot)
|
||
: null;
|
||
return {
|
||
ok: true,
|
||
task_id: current?.task_id,
|
||
status: overlay.status,
|
||
task_input_recorded: Boolean(taskInput?.accepted),
|
||
governance_command_id: taskInput?.command_id,
|
||
governance_event_id: governanceEventIdFromCommand(taskInput),
|
||
};
|
||
}
|
||
|
||
async function recordNotificationTaskInput(
|
||
notification: UserNotification,
|
||
replyContent: string,
|
||
snapshot: QimingclawSnapshot | null,
|
||
): Promise<GovernanceCommandResponse> {
|
||
const stamp = Date.now();
|
||
return handleGovernanceCommand({
|
||
command_kind: 'provide_task_input',
|
||
context_refs: {
|
||
plan_id: notification.plan_id || undefined,
|
||
task_id: notification.task_id,
|
||
},
|
||
payload: {
|
||
input: replyContent,
|
||
source: 'notification_reply',
|
||
notification_id: notification.notification_id,
|
||
plan_id: notification.plan_id || undefined,
|
||
task_id: notification.task_id,
|
||
},
|
||
correlation_id: `qimingclaw-notification-reply-${slugifyIdPart(notification.notification_id)}-${stamp}`,
|
||
idempotency_key: `qimingclaw-notification-reply-${notification.notification_id}`,
|
||
}, snapshot);
|
||
}
|
||
|
||
function governanceEventIdFromCommand(response: GovernanceCommandResponse | null): string | undefined {
|
||
const runId = stringFromUnknown(response?.result?.run_id);
|
||
if (!response?.accepted || !runId || !response.command_id) return undefined;
|
||
return `${runId}:provide_task_input:${safeEventIdPart(response.command_id)}`;
|
||
}
|
||
|
||
function safeEventIdPart(value: string): string {
|
||
return value.replace(/[^a-zA-Z0-9_-]+/g, '-').replace(/^-+|-+$/g, '') || 'unknown';
|
||
}
|
||
|
||
function buildWorkdayDecisions(
|
||
state: AdapterState,
|
||
date: string,
|
||
snapshot: QimingclawSnapshot | null,
|
||
): DigitalEmployeeDecision[] {
|
||
const plansById = new Map(runtimePlans(snapshot).map((plan) => [plan.id, plan]));
|
||
const tasksById = new Map(runtimeTasks(snapshot).map((task) => [task.id, task]));
|
||
const approvalSummaries = new Map(businessApprovalRows(snapshot).map((approval) => [stringValue(approval.approval_id), approval]));
|
||
const resultByDecisionId = state.decisionResultsByDate?.[date] ?? {};
|
||
return buildApprovals(snapshot).filter((approval) => stringValue(approval.source) === 'qimingclaw-runtime').map((approval) => {
|
||
const payload = asRecord(approval.payload);
|
||
const decisionId = stringValue(approval.approval_id)
|
||
|| `approval-${slugifyIdPart(stringValue(approval.task_id) || stringValue(approval.title) || 'item')}`;
|
||
const result = resultByDecisionId[decisionId];
|
||
const status = decisionStatus(result, stringValue(approval.status) || 'pending');
|
||
const planId = stringValue(approval.plan_id);
|
||
const taskId = stringValue(approval.task_id);
|
||
const plan = planId ? plansById.get(planId) : null;
|
||
const task = taskId ? tasksById.get(taskId) : null;
|
||
const summary = approvalSummaries.get(decisionId);
|
||
return {
|
||
id: decisionId,
|
||
title: stringValue(approval.title) || stringValue(payload?.title) || '待确认事项',
|
||
scenario: decisionScenario(approval, payload),
|
||
status,
|
||
status_label: decisionStatusLabel(status, result),
|
||
plan_title: plan?.title || stringValue(payload?.plan_title) || stringValue(approval.plan_id) || 'qimingclaw 本地记录',
|
||
task_title: task?.title || stringValue(payload?.task_title) || stringValue(approval.task_id) || '待确认任务',
|
||
risk_level: stringValue(summary?.risk_level) || 'normal',
|
||
sla_status: stringValue(summary?.sla_status) || 'untracked',
|
||
due_at: stringValue(summary?.due_at) || null,
|
||
last_action: stringValue(summary?.last_action) || null,
|
||
last_actor: stringValue(summary?.last_actor) || null,
|
||
comment_count: numberValue(summary?.comment_count) ?? 0,
|
||
delegate_to: stringValue(summary?.delegate_to) || null,
|
||
actions: isDecisionOpenStatus(status)
|
||
? [
|
||
{ id: 'approved', label: '同意', tone: 'primary' },
|
||
{ id: 'rejected', label: '驳回', tone: 'secondary' },
|
||
]
|
||
: [],
|
||
};
|
||
});
|
||
}
|
||
|
||
function decisionScenario(approval: ApprovalEntry, payload: Record<string, unknown> | null): string {
|
||
return stringValue(payload?.scenario)
|
||
|| stringValue(payload?.summary)
|
||
|| stringValue(payload?.reason)
|
||
|| stringValue(payload?.message)
|
||
|| stringValue(approval.error)
|
||
|| '来自 qimingclaw 本地运行记录的人工确认项。';
|
||
}
|
||
|
||
function decisionStatus(result: string | undefined, originalStatus: string): string {
|
||
const normalizedResult = String(result || '').toLowerCase();
|
||
if (['approve', 'approved', 'accept', 'accepted'].includes(normalizedResult)) return 'approved';
|
||
if (['reject', 'rejected', 'deny', 'denied'].includes(normalizedResult)) return 'rejected';
|
||
if (['dismiss', 'dismissed', 'skip', 'skipped'].includes(normalizedResult)) return 'dismissed';
|
||
return originalStatus || 'pending';
|
||
}
|
||
|
||
function decisionStatusLabel(status: string, result?: string): string {
|
||
if (result) {
|
||
if (status === 'approved') return '已同意';
|
||
if (status === 'rejected') return '已驳回';
|
||
if (status === 'dismissed') return '已忽略';
|
||
return '已处理';
|
||
}
|
||
if (status === 'approved') return '已同意';
|
||
if (status === 'rejected') return '已驳回';
|
||
if (status === 'completed') return '已完成';
|
||
if (status === 'failed') return '异常';
|
||
return '待确认';
|
||
}
|
||
|
||
function isDecisionOpenStatus(status: string): boolean {
|
||
return ['pending', 'requested'].includes(String(status || '').toLowerCase());
|
||
}
|
||
|
||
function buildArtifacts(snapshot: QimingclawSnapshot | null): ArtifactEntry[] {
|
||
const artifacts = [
|
||
...runtimeArtifacts(snapshot).map(artifactFromRuntimeRecord),
|
||
...runtimeRuns(snapshot).flatMap((run) => artifactsForRun(run, runtimeEvents(snapshot))),
|
||
...runtimeEvents(snapshot).flatMap((event) => artifactsFromPayload(event.id, event.payload, event.occurredAt, {
|
||
sourceType: 'event',
|
||
sourceEventId: event.id,
|
||
sourceLabel: `Event ${event.kind}`,
|
||
planId: event.planId,
|
||
taskId: event.taskId,
|
||
runId: event.runId,
|
||
})),
|
||
];
|
||
const deduped = dedupeArtifacts(artifacts);
|
||
return deduped.map((artifact) => withArtifactAccessSummary(artifact, snapshot, deduped));
|
||
}
|
||
|
||
function withArtifactAccessSummary(artifact: ArtifactEntry, snapshot: QimingclawSnapshot | null, artifacts: ArtifactEntry[]): ArtifactEntry {
|
||
const artifactId = stringValue(artifact.artifact_id) || stringValue(artifact.subject_id);
|
||
const lastAccess = artifactAccessRows(snapshot).find((row) => stringValue(row.artifact_id) === artifactId) ?? null;
|
||
const hasLocalUri = isLocalArtifactUri(stringValue(artifact.uri));
|
||
const hasDailyText = isDailyReportArtifact(artifact) && Boolean(stringValue(asRecord(artifact.payload)?.text_content));
|
||
const formalRuntimeArtifact = runtimeArtifacts(snapshot).some((runtime) => runtime.id === artifactId || runtime.remoteId === artifactId);
|
||
const previewable = formalRuntimeArtifact && (hasDailyText || hasLocalUri);
|
||
const lifecycle = artifactLifecycleSummary(snapshot, artifactId);
|
||
const version = artifactVersionMeta(artifacts, artifact);
|
||
return {
|
||
...artifact,
|
||
version: version.version,
|
||
version_key: version.version_key,
|
||
version_rank: version.version_rank,
|
||
retention_status: lifecycle.retention_status,
|
||
retention_until: lifecycle.retention_until,
|
||
last_retention_action: lifecycle.last_retention_action,
|
||
delivery_summary: artifactDeliverySummary(artifact),
|
||
access: {
|
||
previewable,
|
||
downloadable: formalRuntimeArtifact && hasLocalUri,
|
||
openable: formalRuntimeArtifact && hasLocalUri,
|
||
access_policy: formalRuntimeArtifact ? 'qimingclaw-local-artifact-policy' : 'runtime-projection-readonly',
|
||
last_access_status: stringValue(lastAccess?.status) || null,
|
||
},
|
||
};
|
||
}
|
||
|
||
function artifactFromRuntimeRecord(artifact: QimingclawArtifactRecord): ArtifactEntry {
|
||
const payload = asRecord(artifact.payload);
|
||
const delivery = asRecord(payload?.delivery);
|
||
const sourceTool = stringValue(delivery?.source_tool);
|
||
const deliveryUri = stringValue(delivery?.uri);
|
||
const deliveryFilename = stringValue(delivery?.filename);
|
||
return {
|
||
artifact_id: artifact.id,
|
||
subject_id: artifact.runId ?? artifact.taskId ?? artifact.planId ?? artifact.id,
|
||
kind: artifact.kind,
|
||
name: artifact.name || deliveryFilename || stringValue(payload?.name ?? payload?.title) || artifactName(artifact.uri ?? deliveryUri) || artifact.kind,
|
||
uri: artifact.uri || deliveryUri || stringValue(payload?.uri ?? payload?.url ?? payload?.path) || undefined,
|
||
value: stringValue(payload?.value ?? payload?.summary ?? payload?.text) || artifact.uri || deliveryUri || artifact.name || deliveryFilename || artifact.kind,
|
||
plan_id: artifact.planId ?? null,
|
||
task_id: artifact.taskId ?? null,
|
||
run_id: artifact.runId ?? null,
|
||
created_at: artifact.createdAt,
|
||
source: 'qimingclaw-runtime',
|
||
source_type: 'artifact',
|
||
source_label: sourceTool ? `File Server: ${sourceTool}` : artifactSourceLabel('artifact', artifact.id),
|
||
sync_status: artifact.syncStatus,
|
||
sync_error: artifact.syncError,
|
||
payload: artifact.payload,
|
||
...deliveryProjection(delivery),
|
||
};
|
||
}
|
||
|
||
function artifactsForRun(run: QimingclawRunRecord, events: QimingclawEventRecord[]): ArtifactEntry[] {
|
||
return dedupeArtifacts([
|
||
...artifactsFromPayload(run.id, run.payload, run.finishedAt ?? run.startedAt ?? run.createdAt, {
|
||
sourceType: 'run',
|
||
sourceLabel: artifactSourceLabel('run', run.id),
|
||
planId: run.planId,
|
||
taskId: run.taskId,
|
||
runId: run.id,
|
||
}),
|
||
...events
|
||
.filter((event) => event.runId === run.id)
|
||
.flatMap((event) => artifactsFromPayload(run.id, event.payload, event.occurredAt, {
|
||
sourceType: 'event',
|
||
sourceEventId: event.id,
|
||
sourceLabel: `Event ${event.kind}`,
|
||
planId: event.planId,
|
||
taskId: event.taskId,
|
||
runId: event.runId,
|
||
})),
|
||
]);
|
||
}
|
||
|
||
interface ArtifactSourceContext {
|
||
sourceType: string;
|
||
sourceLabel: string;
|
||
sourceEventId?: string | null;
|
||
planId?: string | null;
|
||
taskId?: string | null;
|
||
runId?: string | null;
|
||
}
|
||
|
||
function artifactsFromPayload(
|
||
subjectId: string,
|
||
payload: unknown,
|
||
createdAt?: string | null,
|
||
sourceContext?: ArtifactSourceContext,
|
||
): ArtifactEntry[] {
|
||
const record = asRecord(payload);
|
||
if (!record) return typeof payload === 'string' ? [artifactFromValue(subjectId, payload, 0, createdAt, sourceContext)] : [];
|
||
|
||
const explicitArtifacts = [
|
||
...arrayValue(record.artifacts),
|
||
...arrayValue(record.outputs),
|
||
...arrayValue(record.files),
|
||
...arrayValue(record.attachments),
|
||
];
|
||
const artifacts = explicitArtifacts.map((item, index) => artifactFromValue(subjectId, item, index, createdAt, sourceContext));
|
||
|
||
for (const key of ['artifact', 'outputPath', 'output_path', 'filePath', 'file_path', 'path', 'uri', 'url']) {
|
||
if (record[key]) artifacts.push(artifactFromValue(subjectId, record[key], artifacts.length, createdAt, sourceContext));
|
||
}
|
||
|
||
return artifacts.filter((artifact) => artifact.name || artifact.uri || artifact.value);
|
||
}
|
||
|
||
function artifactFromValue(
|
||
subjectId: string,
|
||
value: unknown,
|
||
index: number,
|
||
createdAt?: string | null,
|
||
sourceContext?: ArtifactSourceContext,
|
||
): ArtifactEntry {
|
||
const record = asRecord(value);
|
||
if (record) {
|
||
const delivery = asRecord(record.delivery);
|
||
const sourceTool = stringValue(delivery?.source_tool);
|
||
const deliveryUri = stringValue(delivery?.uri);
|
||
const uri = stringValue(record.uri ?? record.url ?? record.path ?? record.filePath ?? record.file_path ?? record.outputPath ?? record.output_path);
|
||
const name = stringValue(record.name ?? record.title ?? record.filename) || stringValue(delivery?.filename) || artifactName(uri || deliveryUri) || `产物 ${index + 1}`;
|
||
return {
|
||
artifact_id: stringValue(record.artifact_id ?? record.id) || `artifact-${slugifyIdPart(subjectId)}-${index + 1}`,
|
||
subject_id: stringValue(record.subject_id) || subjectId,
|
||
kind: stringValue(record.kind ?? record.type) || 'artifact',
|
||
name,
|
||
uri: uri || deliveryUri,
|
||
value: stringValue(record.value ?? record.summary ?? record.text) || uri || deliveryUri,
|
||
created_at: (stringValue(record.created_at ?? record.createdAt) || createdAt) ?? undefined,
|
||
source: 'qimingclaw-runtime',
|
||
source_type: stringValue(record.source_type) || sourceContext?.sourceType || 'payload',
|
||
source_event_id: stringValue(record.source_event_id) || sourceContext?.sourceEventId || null,
|
||
source_label: sourceTool ? `File Server: ${sourceTool}` : stringValue(record.source_label) || sourceContext?.sourceLabel || artifactSourceLabel('payload', subjectId),
|
||
plan_id: stringValue(record.plan_id) || sourceContext?.planId || null,
|
||
task_id: stringValue(record.task_id) || sourceContext?.taskId || null,
|
||
run_id: stringValue(record.run_id) || sourceContext?.runId || null,
|
||
...deliveryProjection(delivery),
|
||
};
|
||
}
|
||
|
||
const text = String(value ?? '').trim();
|
||
return {
|
||
artifact_id: `artifact-${slugifyIdPart(subjectId)}-${index + 1}`,
|
||
subject_id: subjectId,
|
||
kind: 'artifact',
|
||
name: artifactName(text) || `产物 ${index + 1}`,
|
||
uri: looksLikeUri(text) ? text : undefined,
|
||
value: text,
|
||
created_at: createdAt ?? undefined,
|
||
source: 'qimingclaw-runtime',
|
||
source_type: sourceContext?.sourceType || 'payload',
|
||
source_event_id: sourceContext?.sourceEventId || null,
|
||
source_label: sourceContext?.sourceLabel || artifactSourceLabel('payload', subjectId),
|
||
plan_id: sourceContext?.planId || null,
|
||
task_id: sourceContext?.taskId || null,
|
||
run_id: sourceContext?.runId || null,
|
||
};
|
||
}
|
||
|
||
function deliveryProjection(delivery: Record<string, unknown> | null): Record<string, unknown> {
|
||
if (!delivery) return {};
|
||
return {
|
||
delivery_status: stringValue(delivery.status) || null,
|
||
delivery_stage: stringValue(delivery.stage) || null,
|
||
workspace_id: stringValue(delivery.workspace_id) || null,
|
||
project_id: stringValue(delivery.project_id) || null,
|
||
file_id: stringValue(delivery.file_id) || null,
|
||
version: stringValue(delivery.version) || null,
|
||
file_size: numberValue(delivery.size),
|
||
source_tool: stringValue(delivery.source_tool) || null,
|
||
};
|
||
}
|
||
|
||
function artifactSourceLabel(sourceType: string, sourceId?: string | null): string {
|
||
const suffix = sourceId ? ` ${sourceId}` : '';
|
||
switch (sourceType) {
|
||
case 'artifact': return `Artifact${suffix}`;
|
||
case 'event': return `Event${suffix}`;
|
||
case 'run': return `Run${suffix}`;
|
||
case 'task': return `Task${suffix}`;
|
||
case 'plan': return `Plan${suffix}`;
|
||
default: return `Payload${suffix}`;
|
||
}
|
||
}
|
||
|
||
function dedupeArtifacts(artifacts: ArtifactEntry[]): ArtifactEntry[] {
|
||
const seen = new Set<string>();
|
||
return artifacts.filter((artifact) => {
|
||
const key = artifact.artifact_id || `${artifact.subject_id}:${artifact.uri || artifact.value || artifact.name}`;
|
||
if (!key || seen.has(key)) return false;
|
||
seen.add(key);
|
||
return Boolean(artifact.name || artifact.uri || artifact.value);
|
||
});
|
||
}
|
||
|
||
function asRecord(value: unknown): Record<string, unknown> | null {
|
||
return value && typeof value === 'object' && !Array.isArray(value)
|
||
? value as Record<string, unknown>
|
||
: null;
|
||
}
|
||
|
||
function arrayValue(value: unknown): unknown[] {
|
||
return Array.isArray(value) ? value : [];
|
||
}
|
||
|
||
function stringValue(value: unknown): string {
|
||
return typeof value === 'string' ? value.trim() : '';
|
||
}
|
||
|
||
function numberValue(value: unknown): number | null {
|
||
if (typeof value === 'number' && Number.isFinite(value)) return value;
|
||
if (typeof value === 'string' && value.trim()) {
|
||
const parsed = Number(value);
|
||
return Number.isFinite(parsed) ? parsed : null;
|
||
}
|
||
return null;
|
||
}
|
||
|
||
function looksLikeUri(value: string): boolean {
|
||
return /^(file|https?):\/\//i.test(value) || value.includes('/') || value.includes('\\');
|
||
}
|
||
|
||
function isLocalArtifactUri(value: string): boolean {
|
||
if (!value) return false;
|
||
if (/^file:\/\//i.test(value)) return true;
|
||
if (/^[a-z][a-z0-9+.-]*:/i.test(value)) return false;
|
||
return value.startsWith('/') || /^[a-z]:[\\/]/i.test(value);
|
||
}
|
||
|
||
function artifactName(value: string): string {
|
||
if (!value) return '';
|
||
const normalized = value.split(/[?#]/)[0] || value;
|
||
return normalized.split(/[\\/]/).filter(Boolean).pop() ?? '';
|
||
}
|
||
|
||
function slugifyIdPart(value: string): string {
|
||
const slug = value
|
||
.trim()
|
||
.toLowerCase()
|
||
.replace(/[^a-z0-9]+/g, '-')
|
||
.replace(/^-+|-+$/g, '');
|
||
if (slug) return slug;
|
||
|
||
let hash = 0;
|
||
for (let index = 0; index < value.length; index += 1) {
|
||
hash = (hash * 31 + value.charCodeAt(index)) >>> 0;
|
||
}
|
||
return `item-${hash.toString(36)}`;
|
||
}
|
||
|
||
function filterPlans(query?: string | null, snapshot: QimingclawSnapshot | null = null): DebugPlan[] {
|
||
const normalized = (query ?? '').trim().toLowerCase();
|
||
const plans = mergedDebugPlans(snapshot);
|
||
if (!normalized) return plans;
|
||
return plans.filter((plan) => (
|
||
plan.title.toLowerCase().includes(normalized)
|
||
|| plan.plan_id.toLowerCase().includes(normalized)
|
||
|| (plan.objective ?? '').toLowerCase().includes(normalized)
|
||
));
|
||
}
|
||
|
||
function buildRuntimeWorkEvents(snapshot: QimingclawSnapshot | null): DigitalEmployeeWorkEvent[] {
|
||
const plansById = new Map(runtimePlans(snapshot).map((plan) => [plan.id, plan]));
|
||
const tasksById = new Map(runtimeTasks(snapshot).map((task) => [task.id, task]));
|
||
const events = runtimeEvents(snapshot).map((event) => {
|
||
const task = event.taskId ? tasksById.get(event.taskId) : undefined;
|
||
const planId = event.planId ?? task?.planId ?? null;
|
||
const plan = planId ? plansById.get(planId) : undefined;
|
||
const status = task?.status ?? plan?.status ?? (event.kind.includes('failed') || event.kind.includes('error') ? 'failed' : 'running');
|
||
const tone = taskStatusTone(status);
|
||
return {
|
||
id: event.id,
|
||
time: formatTime(event.occurredAt),
|
||
plan_title: plan?.title ?? 'qimingclaw 本地执行',
|
||
task_title: task?.title ?? event.message,
|
||
step_title: event.kind,
|
||
detail: event.message || event.kind,
|
||
status,
|
||
status_label: taskStatusLabel(status),
|
||
status_tone: tone,
|
||
updated_at: event.occurredAt,
|
||
conversation_id: planId ?? task?.id ?? event.id,
|
||
};
|
||
});
|
||
if (events.length > 0) return events;
|
||
|
||
return runtimeTasks(snapshot).map((task) => {
|
||
const plan = task.planId ? plansById.get(task.planId) : undefined;
|
||
return {
|
||
id: `task-event-${task.id}`,
|
||
time: formatTime(task.updatedAt),
|
||
plan_title: plan?.title ?? 'qimingclaw 本地任务',
|
||
task_title: task.title,
|
||
step_title: task.assignedSkillId || 'qimingclaw-runtime',
|
||
detail: task.syncError || `${task.title}：${taskStatusLabel(task.status)}，同步状态 ${task.syncStatus}`,
|
||
status: task.status,
|
||
status_label: taskStatusLabel(task.status),
|
||
status_tone: taskStatusTone(task.status),
|
||
updated_at: task.updatedAt,
|
||
conversation_id: task.planId ?? task.id,
|
||
};
|
||
});
|
||
}
|
||
|
||
function buildEvents(duties: DigitalEmployeeDuty[], confirmed: boolean, snapshot: QimingclawSnapshot | null): DigitalEmployeeWorkEvent[] {
|
||
if (hasRuntimeRecords(snapshot)) {
|
||
const runtimeWorkEvents = buildRuntimeWorkEvents(snapshot);
|
||
return appendSyncEvent(runtimeWorkEvents, snapshot);
|
||
}
|
||
if (!confirmed) {
|
||
return [{
|
||
id: 'event-await-confirmation',
|
||
time: '待确认',
|
||
plan_title: '任务设置',
|
||
task_title: '等待确认今日任务',
|
||
step_title: '选择职责',
|
||
detail: '请先确认今天要执行的任务，确认后数字员工会开始执行。',
|
||
status: 'pending',
|
||
status_label: '待确认',
|
||
status_tone: 'waiting',
|
||
updated_at: new Date().toISOString(),
|
||
conversation_id: null,
|
||
}];
|
||
}
|
||
|
||
const selectedDuties = duties.filter((duty) => duty.selected);
|
||
const events = selectedDuties.map((duty) => ({
|
||
id: `event-${duty.id}`,
|
||
time: duty.status === 'running' ? '实时' : '待执行',
|
||
plan_title: duty.title,
|
||
task_title: duty.title,
|
||
step_title: duty.status === 'running' ? '同步 qimingclaw 服务状态' : '等待调度',
|
||
detail: duty.status === 'running'
|
||
? `${duty.result_text}。快照时间：${snapshot?.generatedAt ?? '未连接 bridge'}`
|
||
: '任务已确认，将在后续阶段接入 ACP/MCP 真实执行事件。',
|
||
status: duty.status === 'running' ? 'running' : 'pending',
|
||
status_label: duty.status === 'running' ? '执行中' : '待执行',
|
||
status_tone: duty.status === 'running' ? 'running' : 'waiting',
|
||
updated_at: new Date().toISOString(),
|
||
conversation_id: duty.conversation_id,
|
||
}));
|
||
return appendSyncEvent(events, snapshot);
|
||
}
|
||
|
||
function appendSyncEvent(events: DigitalEmployeeWorkEvent[], snapshot: QimingclawSnapshot | null): DigitalEmployeeWorkEvent[] {
|
||
const sync = snapshot?.sync;
|
||
if (sync && (sync.pending > 0 || sync.failed > 0 || sync.lastSyncAt)) {
|
||
const recentFailureText = (sync.recentFailures || [])
|
||
.slice(0, 3)
|
||
.map(syncFailureLine)
|
||
.join('；');
|
||
return [...events, {
|
||
id: 'event-management-sync',
|
||
time: sync.syncing ? '实时' : '同步',
|
||
plan_title: '管理端联动',
|
||
task_title: '同步数字员工本地状态',
|
||
step_title: sync.failed > 0 ? '同步补偿' : 'outbox 推送',
|
||
detail: [
|
||
syncLine(snapshot),
|
||
sync.lastSyncError ? `错误：${sync.lastSyncError}` : '',
|
||
recentFailureText ? `最近失败：${recentFailureText}` : '',
|
||
].filter(Boolean).join('。'),
|
||
status: sync.failed > 0 ? 'failed' : sync.syncing || sync.pending > 0 ? 'running' : 'completed',
|
||
status_label: sync.failed > 0 ? '异常' : sync.syncing || sync.pending > 0 ? '同步中' : '已同步',
|
||
status_tone: sync.failed > 0 ? 'danger' : sync.syncing || sync.pending > 0 ? 'running' : 'success',
|
||
updated_at: sync.lastSyncAt ?? new Date().toISOString(),
|
||
conversation_id: 'qimingclaw-management-sync',
|
||
}];
|
||
}
|
||
return events;
|
||
}
|
||
|
||
function buildExecutionSummaries(duties: DigitalEmployeeDuty[], events: DigitalEmployeeWorkEvent[]): DigitalEmployeeTaskExecutionSummary[] {
|
||
const selectedDuties = duties.some((duty) => duty.selected) ? duties.filter((duty) => duty.selected) : duties;
|
||
return selectedDuties.map((duty) => {
|
||
const related = events.filter((event) => event.conversation_id === duty.conversation_id);
|
||
const running = related.filter((event) => event.status === 'running').length;
|
||
const success = related.filter((event) => event.status === 'completed').length;
|
||
const failure = related.filter((event) => taskStatusTone(event.status) === 'danger').length;
|
||
const waiting = Math.max(0, related.length - running - success - failure);
|
||
return {
|
||
id: duty.id,
|
||
plan_id: duty.id,
|
||
title: duty.title,
|
||
description: duty.summary,
|
||
selected: duty.selected,
|
||
total_count: Math.max(related.length, 1),
|
||
success_count: success,
|
||
failure_count: failure,
|
||
running_count: running,
|
||
waiting_count: related.length === 0 ? 1 : waiting,
|
||
latest_status_label: failure > 0 ? '异常' : running > 0 ? '执行中' : success > 0 ? '已完成' : '待执行',
|
||
latest_status_tone: failure > 0 ? 'danger' : running > 0 ? 'running' : success > 0 ? 'success' : 'waiting',
|
||
business_summary: duty.result_text,
|
||
ai_summary: '当前由 qimingclaw 本地运行记录生成。',
|
||
};
|
||
});
|
||
}
|
||
|
||
function buildRunDetails(events: DigitalEmployeeWorkEvent[]): DigitalEmployeeRunDetail[] {
|
||
return events.map((event) => ({
|
||
id: `run-detail-${event.id}`,
|
||
time: event.time,
|
||
task_name: event.task_title,
|
||
step_name: event.step_title,
|
||
operation_name: event.plan_title,
|
||
status_label: event.status_label,
|
||
status_tone: event.status_tone,
|
||
business_detail: event.detail,
|
||
raw_detail: event.detail,
|
||
updated_at: event.updated_at,
|
||
conversation_id: event.conversation_id,
|
||
}));
|
||
}
|
||
|
||
function buildWorkday(date: string, snapshot: QimingclawSnapshot | null): DigitalEmployeeWorkdayProjection {
|
||
const state = snapshot?.uiState ?? readState();
|
||
const confirmedAt = state.confirmedDates[date] ?? null;
|
||
const confirmed = Boolean(confirmedAt);
|
||
const duties = buildDuties(state, date, snapshot);
|
||
const events = buildEvents(duties, confirmed, snapshot);
|
||
const executionSummaries = buildExecutionSummaries(duties, events);
|
||
const generatedAt = state.reportGeneratedAtByDate[date] ?? null;
|
||
const selectedCount = duties.filter((duty) => duty.selected).length;
|
||
const runningCount = events.filter((event) => event.status === 'running').length;
|
||
const successCount = events.filter((event) => taskStatusTone(event.status) === 'success').length;
|
||
const failureCount = events.filter((event) => taskStatusTone(event.status) === 'danger').length;
|
||
const liveRecordCount = runtimePlans(snapshot).length + runtimeTasks(snapshot).length;
|
||
const hasLiveRuntime = hasRuntimeRecords(snapshot);
|
||
const sync = snapshot?.sync;
|
||
const artifactSources = reportArtifactSources(buildArtifacts(snapshot));
|
||
const runDetails = buildRunDetails(events);
|
||
const managedServices = buildManagedServices(snapshot);
|
||
const managedServiceIssues = managedServices.filter((service) => service.requires_human_action || service.status === 'degraded');
|
||
const runningManagedServiceCount = managedServices.filter((service) => service.running).length;
|
||
const planAgents = buildPlanAgents(snapshot);
|
||
const taskAgents = buildTaskAgents(snapshot);
|
||
const actionableTaskAgents = taskAgents.filter((agent) => agent.can_retry || agent.can_skip || agent.can_cancel);
|
||
|
||
return {
|
||
source: 'live',
|
||
date,
|
||
employee: {
|
||
name: state.profile.name,
|
||
title: '数字员工',
|
||
major: 'qimingclaw 客户端任务执行',
|
||
company: state.profile.company,
|
||
position: state.profile.position,
|
||
current_status: state.profile.currentStatus,
|
||
current_status_label: state.profile.currentStatus === 'resting' ? '休息中' : '工作中',
|
||
motto: '承接客户端任务，调度 ACP 与 MCP 能力完成执行。',
|
||
},
|
||
workday: {
|
||
confirmed,
|
||
confirmed_at: confirmedAt,
|
||
current_status: state.profile.currentStatus,
|
||
current_status_label: state.profile.currentStatus === 'resting' ? '休息中' : '工作中',
|
||
status_label: hasLiveRuntime
|
||
? (failureCount > 0 || managedServiceIssues.length > 0 ? '有异常' : runningCount > 0 ? '执行中' : '已同步')
|
||
: confirmed ? '运行中' : '待确认',
|
||
status_tone: hasLiveRuntime
|
||
? (failureCount > 0 || managedServiceIssues.length > 0 ? 'danger' : runningCount > 0 ? 'running' : 'success')
|
||
: confirmed ? 'running' : 'waiting',
|
||
summary: hasLiveRuntime
|
||
? `当前日期 ${displayDate(date)} 已读取 ${liveRecordCount} 条 qimingclaw 本地运行记录，${managedServiceSummary(managedServices)}。`
|
||
: confirmed
|
||
? `当前日期 ${displayDate(date)} 已确认 ${selectedCount} 项任务。`
|
||
: `当前日期 ${displayDate(date)} 待确认今日任务。`,
|
||
bubble_text: hasLiveRuntime
|
||
? managedServiceIssues.length > 0
|
||
? `我发现 ${managedServiceIssues.length} 项常驻服务需要处理，会把影响到的任务标出来。`
|
||
: '我已接入 qimingclaw 本地运行记录，会持续展示真实任务、事件和同步状态。'
|
||
: confirmed
|
||
? '我已接入 qimingclaw 客户端执行链路，正在等待真实 Run/Event 数据接入。'
|
||
: '请先确认今天要执行的任务，我会把它们映射到 qimingclaw 执行链路。',
|
||
},
|
||
overview: {
|
||
title: '今日执行',
|
||
status_label: hasLiveRuntime ? '本地真实记录' : confirmed ? '真实数据' : '待确认',
|
||
status_tone: failureCount > 0 ? 'danger' : hasLiveRuntime || confirmed ? 'success' : 'waiting',
|
||
metrics: [
|
||
{ label: '已选任务', value: String(selectedCount) },
|
||
{ label: '运行记录', value: String(events.length) },
|
||
{ label: '执行中', value: String(runningCount) },
|
||
{ label: '已完成', value: String(successCount) },
|
||
{ label: '异常', value: String(failureCount) },
|
||
{ label: '待同步', value: String(sync?.pending ?? 0) },
|
||
{ label: '同步异常', value: String(sync?.failed ?? 0) },
|
||
{ label: '服务运行', value: `${runningManagedServiceCount}/${managedServices.length}` },
|
||
{ label: '需处理服务', value: String(managedServiceIssues.length) },
|
||
{ label: 'Plan Agent', value: String(planAgents.length) },
|
||
{ label: 'Task Agent', value: String(taskAgents.length) },
|
||
{ label: '可治理任务', value: String(actionableTaskAgents.length) },
|
||
],
|
||
},
|
||
managed_services: managedServices,
|
||
plan_agents: planAgents,
|
||
task_agents: taskAgents,
|
||
duties,
|
||
events,
|
||
execution_summaries: executionSummaries,
|
||
run_details: runDetails,
|
||
decisions: buildWorkdayDecisions(state, date, snapshot),
|
||
delivery: {
|
||
headline: hasLiveRuntime ? 'qimingclaw 本地记录已接入' : confirmed ? 'qimingclaw 执行链路已接入' : '等待确认任务设置',
|
||
summary: hasLiveRuntime
|
||
? '数字员工页面正在读取本地 Plan / Task / Run / Event，并同步展示管理端 outbox 状态。'
|
||
: '当前阶段已将数字员工页面切换到 qimingclaw adapter，并开始读取客户端服务状态。',
|
||
lines: [
|
||
'已吸收 sgRobot 数字员工 UI 和核心展示模型。',
|
||
hasLiveRuntime
|
||
? `已读取本地记录：Plan ${runtimePlans(snapshot).length} / Task ${runtimeTasks(snapshot).length} / Run ${runtimeRuns(snapshot).length} / Event ${runtimeEvents(snapshot).length}。`
|
||
: '已建立 qimingclaw workday/plans/tasks/skills API adapter。',
|
||
serviceLine(snapshot, 'agent', 'Agent'),
|
||
serviceLine(snapshot, 'mcp', 'MCP'),
|
||
serviceLine(snapshot, 'computerServer', 'Computer Server'),
|
||
managedServiceSummary(managedServices),
|
||
...managedServiceIssues.slice(0, 3).map(managedServiceLine),
|
||
`Plan Agent：${planAgents.length} 个计划代理，Task Agent：${taskAgents.length} 个任务代理。`,
|
||
actionableTaskAgents[0]
|
||
? `待治理任务：${actionableTaskAgents[0].title}，下一步 ${actionableTaskAgents[0].next_action}。`
|
||
: 'Task Agent：暂无需要重试、跳过或取消的任务。',
|
||
syncLine(snapshot),
|
||
`活跃会话：${snapshot?.sessions.active ?? 0} / ${snapshot?.sessions.total ?? 0}`,
|
||
],
|
||
artifacts: [
|
||
{ name: '数字员工运行摘要', status: generatedAt ? 'ready' : 'pending' },
|
||
...artifactSources.slice(0, 4).map((artifact) => ({
|
||
name: artifact.name,
|
||
status: generatedAt ? 'ready' : 'available',
|
||
uri: artifact.uri ?? null,
|
||
source_label: artifact.source_label ?? null,
|
||
source_type: artifact.source_type ?? null,
|
||
})),
|
||
],
|
||
},
|
||
route_summary: buildRouteDecisionSummary(snapshot),
|
||
diagnostic_summary: buildDiagnosticSummary(snapshot),
|
||
daily_report: buildDailyReportProjection({ date, state, generatedAt, selectedCount, events, executionSummaries, runDetails, artifactSources, successCount, failureCount, runningCount, snapshot }),
|
||
};
|
||
}
|
||
|
||
function buildDailyReportProjection(input: {
|
||
date: string;
|
||
state: AdapterState;
|
||
generatedAt: string | null;
|
||
selectedCount: number;
|
||
events: DigitalEmployeeWorkEvent[];
|
||
executionSummaries: DigitalEmployeeTaskExecutionSummary[];
|
||
runDetails: DigitalEmployeeRunDetail[];
|
||
artifactSources: ReturnType<typeof reportArtifactSources>;
|
||
successCount: number;
|
||
failureCount: number;
|
||
runningCount: number;
|
||
snapshot: QimingclawSnapshot | null;
|
||
}): DigitalEmployeeDailyReport {
|
||
const title = `${displayDate(input.date)} 飞天数字员工日报`;
|
||
const summary = input.generatedAt
|
||
? `今日已完成数字员工页面到 qimingclaw adapter 的接入，并读取了 qimingclaw 服务状态。${syncLine(input.snapshot)}。`
|
||
: '日报将在生成后汇总任务选择、运行明细和后续接入建议。';
|
||
const totals = {
|
||
task_count: input.selectedCount,
|
||
execution_count: input.events.length,
|
||
success_count: input.successCount,
|
||
failure_count: input.failureCount,
|
||
running_count: input.runningCount,
|
||
};
|
||
const detailLines = input.events.map((event) => `${event.time} ${event.task_title}：${event.detail}`);
|
||
const reportId = input.generatedAt ? dailyReportId(input.date, input.generatedAt) : null;
|
||
const downloadFilename = dailyReportFilename(input.date);
|
||
const baseReport: DigitalEmployeeDailyReport = {
|
||
report_id: reportId,
|
||
artifact_id: reportId ? `${reportId}:artifact:text` : null,
|
||
event_id: reportId ? `${reportId}:event:generated` : null,
|
||
date: input.date,
|
||
title,
|
||
report_schedule_time: input.state.reportScheduleTime,
|
||
status: input.generatedAt ? 'ready' : 'not_generated',
|
||
generated_at: input.generatedAt,
|
||
generated_by: input.generatedAt ? 'ai' : 'fallback',
|
||
model: 'qimingclaw-adapter',
|
||
source: 'qimingclaw',
|
||
summary,
|
||
totals,
|
||
task_sections: input.executionSummaries,
|
||
detail_lines: detailLines,
|
||
artifact_sources: input.artifactSources,
|
||
download_filename: downloadFilename,
|
||
text_content: null,
|
||
pdf_available: Boolean(input.generatedAt),
|
||
pdf_url: null,
|
||
};
|
||
return {
|
||
...baseReport,
|
||
text_content: input.generatedAt
|
||
? buildDailyReportText(baseReport, input.runDetails, input.artifactSources)
|
||
: null,
|
||
};
|
||
}
|
||
|
||
function buildDailyReportText(
|
||
report: DigitalEmployeeDailyReport,
|
||
details: DigitalEmployeeRunDetail[],
|
||
artifacts: ReturnType<typeof reportArtifactSources>,
|
||
): string {
|
||
return [
|
||
report.title || `${report.date} 数字员工日报`,
|
||
`日期：${report.date}`,
|
||
`生成时间：${report.generated_at || '暂未生成'}`,
|
||
`生成来源：${report.generated_by === 'ai' ? 'AI' : 'qimingclaw adapter'}`,
|
||
'',
|
||
'## 摘要',
|
||
report.summary || '暂无摘要。',
|
||
'',
|
||
'## 指标',
|
||
`任务总数：${report.totals.task_count}`,
|
||
`执行次数：${report.totals.execution_count}`,
|
||
`成功次数：${report.totals.success_count}`,
|
||
`失败次数：${report.totals.failure_count}`,
|
||
`运行中：${report.totals.running_count ?? 0}`,
|
||
'',
|
||
'## 任务汇总',
|
||
...(report.task_sections.length > 0
|
||
? report.task_sections.map((section) => `- ${section.title}：${section.latest_status_label}，执行 ${section.total_count} 次，成功 ${section.success_count}，失败 ${section.failure_count}。${section.ai_summary || section.business_summary || ''}`)
|
||
: ['暂无任务汇总。']),
|
||
'',
|
||
'## 运行明细',
|
||
...(details.length > 0
|
||
? details.map((detail) => `- ${detail.time || '--:--'} ${detail.task_name} / ${detail.step_name || detail.operation_name || '任务执行'}：${detail.status_label}，${detail.business_detail}`)
|
||
: ['暂无运行明细。']),
|
||
'',
|
||
'## 产物来源',
|
||
...(artifacts.length > 0
|
||
? artifacts.map((artifact) => `- ${artifact.name}：${artifact.source_label || artifact.source_type || '未知来源'}${artifact.uri ? `，${artifact.uri}` : ''}`)
|
||
: ['暂无产物来源。']),
|
||
'',
|
||
'## 详情',
|
||
...((report.detail_lines ?? []).length > 0 ? report.detail_lines : ['暂无详情。']),
|
||
].join('\n');
|
||
}
|
||
|
||
function dailyReportFilename(date: string): string {
|
||
return `qimingclaw-digital-report-${date}.txt`;
|
||
}
|
||
|
||
function dailyReportId(date: string, generatedAt: string): string {
|
||
return `daily-report:${date}:${slugifyIdPart(generatedAt)}`;
|
||
}
|
||
|
||
function reportArtifactSources(artifacts: ArtifactEntry[]) {
|
||
return artifacts.slice(0, 20).map((artifact) => ({
|
||
id: stringValue(artifact.artifact_id) || `${stringValue(artifact.subject_id)}:${stringValue(artifact.uri ?? artifact.name)}`,
|
||
name: stringValue(artifact.name) || stringValue(artifact.uri) || stringValue(artifact.value) || '未命名产物',
|
||
kind: stringValue(artifact.kind) || null,
|
||
uri: stringValue(artifact.uri) || null,
|
||
delivery_status: stringValue(artifact.delivery_status) || null,
|
||
delivery_stage: stringValue(artifact.delivery_stage) || null,
|
||
workspace_id: stringValue(artifact.workspace_id) || null,
|
||
project_id: stringValue(artifact.project_id) || null,
|
||
file_id: stringValue(artifact.file_id) || null,
|
||
version: stringValue(artifact.version) || null,
|
||
version_key: stringValue(artifact.version_key) || null,
|
||
version_rank: numberValue(artifact.version_rank),
|
||
retention_status: stringValue(artifact.retention_status) || null,
|
||
retention_until: stringValue(artifact.retention_until) || null,
|
||
last_retention_action: stringValue(artifact.last_retention_action) || null,
|
||
file_size: typeof artifact.file_size === 'number' ? artifact.file_size : null,
|
||
source_tool: stringValue(artifact.source_tool) || null,
|
||
source_label: stringValue(artifact.source_label) || null,
|
||
source_type: stringValue(artifact.source_type) || null,
|
||
source_event_id: stringValue(artifact.source_event_id) || null,
|
||
plan_id: stringValue(artifact.plan_id) || null,
|
||
task_id: stringValue(artifact.task_id) || null,
|
||
run_id: stringValue(artifact.run_id) || null,
|
||
created_at: stringValue(artifact.created_at) || null,
|
||
access: artifact.access,
|
||
delivery_summary: artifact.delivery_summary ?? null,
|
||
}));
|
||
}
|
||
|
||
async function handleWorkdayAction(body: DigitalEmployeeWorkdayActionRequest, snapshot: QimingclawSnapshot | null): Promise<DigitalEmployeeWorkdayProjection> {
|
||
const state = snapshot?.uiState ?? await readBridgeUiState() ?? readState();
|
||
const date = body.date || todayInputDate();
|
||
|
||
if (body.action === 'confirm_workday') {
|
||
state.selectedDutyIdsByDate[date] = body.duty_ids ?? [];
|
||
state.confirmedDates[date] = new Date().toISOString();
|
||
}
|
||
if (body.action === 'update_profile') {
|
||
state.profile = {
|
||
name: body.name || state.profile.name,
|
||
company: body.company || state.profile.company,
|
||
position: body.position || state.profile.position,
|
||
currentStatus: body.current_status || state.profile.currentStatus,
|
||
};
|
||
}
|
||
if (body.action === 'update_report_schedule') {
|
||
state.reportScheduleTime = body.report_schedule_time || state.reportScheduleTime;
|
||
}
|
||
if (body.action === 'generate_daily_report') {
|
||
if (body.duty_ids) state.selectedDutyIdsByDate[date] = body.duty_ids;
|
||
if (body.report_schedule_time) state.reportScheduleTime = body.report_schedule_time;
|
||
state.reportGeneratedAtByDate[date] = new Date().toISOString();
|
||
}
|
||
if (body.action === 'decide_approval' && body.decision_id) {
|
||
state.decisionResultsByDate = state.decisionResultsByDate ?? {};
|
||
state.decisionResultsByDate[date] = {
|
||
...(state.decisionResultsByDate[date] ?? {}),
|
||
[body.decision_id]: body.decision || 'resolved',
|
||
};
|
||
}
|
||
|
||
const acpPermissionResult = body.action === 'decide_approval'
|
||
? await respondAcpPermissionForDecision(body, snapshot)
|
||
: null;
|
||
|
||
const savedState = await saveState(
|
||
state,
|
||
body.action,
|
||
date,
|
||
body.action === 'decide_approval'
|
||
? {
|
||
decision_id: body.decision_id,
|
||
decision: body.decision,
|
||
acp_permission: acpPermissionResult,
|
||
}
|
||
: undefined,
|
||
);
|
||
const nextSnapshot = { ...(snapshot ?? { generatedAt: new Date().toISOString(), services: {}, sessions: { total: 0, active: 0, items: [] } }), uiState: savedState };
|
||
const projection = buildWorkday(date, nextSnapshot);
|
||
if (body.action === 'generate_daily_report' && projection.daily_report) {
|
||
await recordDailyReportArtifact(projection.daily_report);
|
||
}
|
||
return projection;
|
||
}
|
||
|
||
async function recordDailyReportArtifact(report: DigitalEmployeeDailyReport): Promise<void> {
|
||
if (!report.report_id || !report.generated_at || !report.text_content) return;
|
||
try {
|
||
await window.QimingClawBridge?.digital?.recordDailyReport?.({
|
||
reportId: report.report_id,
|
||
date: report.date,
|
||
title: report.title,
|
||
summary: report.summary,
|
||
totals: report.totals,
|
||
detailLines: report.detail_lines,
|
||
artifactSources: report.artifact_sources ?? [],
|
||
filename: report.download_filename || dailyReportFilename(report.date),
|
||
textContent: report.text_content,
|
||
generatedAt: report.generated_at,
|
||
reportScheduleTime: report.report_schedule_time,
|
||
source: report.source ?? 'qimingclaw',
|
||
model: report.model ?? 'qimingclaw-adapter',
|
||
});
|
||
} catch (error) {
|
||
console.warn('[qimingclawAdapter] record daily report failed:', error);
|
||
}
|
||
}
|
||
|
||
async function respondAcpPermissionForDecision(
|
||
body: DigitalEmployeeWorkdayActionRequest,
|
||
snapshot: QimingclawSnapshot | null,
|
||
): Promise<Record<string, unknown> | null> {
|
||
if (!body.decision_id || !body.decision) return null;
|
||
const approval = findApprovalForDecision(body.decision_id, snapshot);
|
||
if (!approval) return null;
|
||
const refs = acpPermissionRefs(approval);
|
||
if (!refs) return null;
|
||
const response = acpResponseForDecision(body.decision);
|
||
const respondPermission = window.QimingClawBridge?.digital?.respondPermission;
|
||
if (!respondPermission) return null;
|
||
try {
|
||
const result = await respondPermission(refs.sessionId, refs.permissionId, response);
|
||
return {
|
||
permission_id: refs.permissionId,
|
||
session_id: refs.sessionId,
|
||
response,
|
||
success: result?.success !== false,
|
||
error: result?.error,
|
||
};
|
||
} catch (error) {
|
||
return {
|
||
permission_id: refs.permissionId,
|
||
session_id: refs.sessionId,
|
||
response,
|
||
success: false,
|
||
error: error instanceof Error ? error.message : String(error),
|
||
};
|
||
}
|
||
}
|
||
|
||
function findApprovalForDecision(decisionId: string, snapshot: QimingclawSnapshot | null): ApprovalEntry | null {
|
||
return buildApprovals(snapshot).find((approval) => stringValue(approval.approval_id) === decisionId) ?? null;
|
||
}
|
||
|
||
function acpPermissionRefs(approval: ApprovalEntry): { permissionId: string; sessionId: string } | null {
|
||
const payload = asRecord(approval.payload);
|
||
const nestedPayload = asRecord(payload?.payload);
|
||
const permissionId = stringValue(payload?.permissionId)
|
||
|| stringValue(payload?.permission_id)
|
||
|| stringValue(payload?.id)
|
||
|| stringValue(nestedPayload?.permissionId)
|
||
|| stringValue(nestedPayload?.permission_id)
|
||
|| stringValue(nestedPayload?.id);
|
||
const sessionId = stringValue(payload?.sessionId)
|
||
|| stringValue(payload?.session_id)
|
||
|| stringValue(nestedPayload?.sessionId)
|
||
|| stringValue(nestedPayload?.session_id);
|
||
const source = stringValue(payload?.source);
|
||
if (!permissionId || !sessionId || (source && source !== 'acp-permission')) return null;
|
||
return { permissionId, sessionId };
|
||
}
|
||
|
||
function acpResponseForDecision(decision: string): 'once' | 'always' | 'reject' {
|
||
const normalized = decision.toLowerCase();
|
||
if (normalized.includes('always')) return 'always';
|
||
if (normalized.includes('reject') || normalized.includes('deny')) return 'reject';
|
||
return 'once';
|
||
}
|
||
|
||
async function handlePlanAction(
|
||
planId: string,
|
||
action: string,
|
||
snapshot: QimingclawSnapshot | null,
|
||
payload: Record<string, unknown> = {},
|
||
): Promise<GovernanceCommandResponse> {
|
||
const commandKind = planActionCommandKind(action);
|
||
const correlationId = `plan-action-${slugifyIdPart(planId)}-${slugifyIdPart(action)}-${Date.now()}`;
|
||
if (!commandKind) {
|
||
return {
|
||
command_id: `qimingclaw-digital-plan-action-${Date.now()}`,
|
||
accepted: false,
|
||
correlation_id: correlationId,
|
||
message: `暂不支持计划动作：${action}`,
|
||
error: 'unsupported_command',
|
||
};
|
||
}
|
||
return handleGovernanceCommand({
|
||
command_kind: commandKind,
|
||
context_refs: { plan_id: planId },
|
||
payload: {
|
||
...payload,
|
||
plan_id: planId,
|
||
requested_action: `plan_${action}`,
|
||
action_endpoint: `/api/debug/plan/${planId}/${action}`,
|
||
},
|
||
correlation_id: correlationId,
|
||
}, snapshot);
|
||
}
|
||
|
||
async function handleTaskAction(
|
||
taskId: string,
|
||
action: string,
|
||
snapshot: QimingclawSnapshot | null,
|
||
payload: Record<string, unknown> = {},
|
||
): Promise<GovernanceCommandResponse> {
|
||
const commandKind = taskActionCommandKind(action);
|
||
const task = runtimeTasks(snapshot).find((candidate) => candidate.id === taskId);
|
||
const latestRun = latestRunForTask(runtimeRuns(snapshot), taskId);
|
||
const planId = task?.planId ?? (stringValue(payload.plan_id) || undefined);
|
||
const runId = latestRun?.id ?? (stringValue(payload.run_id) || undefined);
|
||
const stepId = task ? taskStepId(task) : (stringValue(payload.step_id) || undefined);
|
||
const correlationId = `task-action-${slugifyIdPart(taskId)}-${slugifyIdPart(action)}-${Date.now()}`;
|
||
if (!commandKind) {
|
||
return {
|
||
command_id: `qimingclaw-digital-task-action-${Date.now()}`,
|
||
accepted: false,
|
||
correlation_id: correlationId,
|
||
message: `暂不支持任务动作：${action}`,
|
||
error: 'unsupported_command',
|
||
};
|
||
}
|
||
return handleGovernanceCommand({
|
||
command_kind: commandKind,
|
||
context_refs: {
|
||
plan_id: planId,
|
||
task_id: taskId,
|
||
run_id: runId,
|
||
step_id: stepId,
|
||
},
|
||
payload: {
|
||
...payload,
|
||
task_id: taskId,
|
||
plan_id: planId ?? payload.plan_id,
|
||
run_id: runId ?? payload.run_id,
|
||
step_id: stepId ?? payload.step_id,
|
||
requested_action: `task_${action}`,
|
||
action_endpoint: `/api/task/${taskId}/${action}`,
|
||
},
|
||
correlation_id: correlationId,
|
||
}, snapshot);
|
||
}
|
||
|
||
function planActionCommandKind(action: string): GovernanceCommandRequest['command_kind'] | null {
|
||
switch (action.toLowerCase()) {
|
||
case 'submit':
|
||
return 'submit_plan';
|
||
case 'approve':
|
||
return 'approve_plan';
|
||
case 'activate':
|
||
return 'activate_plan';
|
||
case 'pause':
|
||
return 'pause_plan';
|
||
case 'resume':
|
||
return 'resume_plan';
|
||
case 'cancel':
|
||
return 'cancel_plan';
|
||
case 'amend':
|
||
return 'amend_plan';
|
||
default:
|
||
return null;
|
||
}
|
||
}
|
||
|
||
function taskActionCommandKind(action: string): GovernanceCommandRequest['command_kind'] | null {
|
||
switch (action.toLowerCase()) {
|
||
case 'retry':
|
||
return 'retry_task';
|
||
case 'skip':
|
||
return 'skip_task';
|
||
case 'pause':
|
||
return 'pause_task';
|
||
case 'resume':
|
||
return 'resume_task';
|
||
case 'cancel':
|
||
return 'cancel_task';
|
||
case 'start':
|
||
return 'start_run';
|
||
default:
|
||
return null;
|
||
}
|
||
}
|
||
|
||
function buildPlanRevisions(planId: string, snapshot: QimingclawSnapshot | null): { plan_id: string; revisions: Array<Record<string, unknown>> } {
|
||
const revisions = runtimeEvents(snapshot)
|
||
.filter((event) => event.planId === planId && event.kind.startsWith('governance_'))
|
||
.sort((left, right) => right.occurredAt.localeCompare(left.occurredAt) || right.createdAt.localeCompare(left.createdAt))
|
||
.map((event) => {
|
||
const payload = asRecord(event.payload) ?? {};
|
||
const result = asRecord(payload.result) ?? {};
|
||
const commandKind = stringValue(payload.commandKind) || event.kind.replace(/^governance_/, '');
|
||
return {
|
||
revision_id: event.id,
|
||
plan_id: planId,
|
||
event_id: event.id,
|
||
command_kind: commandKind,
|
||
action: commandKind.replace(/_plan$/, ''),
|
||
status: stringValue(result.status) || stringValue(payload.status) || 'recorded',
|
||
message: event.message,
|
||
created_at: event.occurredAt,
|
||
payload,
|
||
};
|
||
});
|
||
return { plan_id: planId, revisions };
|
||
}
|
||
|
||
async function readRouteDecisions(limit = 80): Promise<RouteDecisionTimelineResponse> {
|
||
const bridge = window.QimingClawBridge?.digital;
|
||
if (!bridge?.listRouteDecisions) {
|
||
return { has_route_decision_state: false, decisions: [] };
|
||
}
|
||
try {
|
||
const decisions = await bridge.listRouteDecisions({ limit });
|
||
return { has_route_decision_state: true, decisions: decisions ?? [] };
|
||
} catch (error) {
|
||
console.warn('[qimingclawAdapter] list route decisions failed:', error);
|
||
return { has_route_decision_state: false, decisions: [] };
|
||
}
|
||
}
|
||
|
||
async function handleIngressRoute(
|
||
body: IngressRouteRequest,
|
||
snapshot: QimingclawSnapshot | null,
|
||
): Promise<IngressRouteResponse> {
|
||
const recordedAt = body.timestamp || new Date().toISOString();
|
||
const correlationId = body.correlation_id || `route-${Date.now()}`;
|
||
const idSource = body.idempotency_key || correlationId;
|
||
const contextRefs = buildIngressContextRefs(body);
|
||
const classification = classifyIngressRoute(body, contextRefs, snapshot);
|
||
const filteredCandidates = await filterRouteCandidateSkills(classification.candidateSkills);
|
||
const reasonCodes = filteredCandidates.allCandidatesDisabled
|
||
? [...classification.reasonCodes, 'candidate_skills_disabled']
|
||
: classification.reasonCodes;
|
||
const decision: RouteDecisionRecord = {
|
||
id: `route-decision-${slugifyIdPart(idSource)}`,
|
||
route_kind: classification.routeKind,
|
||
intent_kind: classification.intentKind,
|
||
reason_codes: reasonCodes,
|
||
candidate_skills: filteredCandidates.candidateSkills,
|
||
context_refs: contextRefs,
|
||
created_command_id: null,
|
||
correlation_id: correlationId,
|
||
creates_plan: classification.createsPlan,
|
||
creates_task_run: classification.createsTaskRun,
|
||
approval_mode: null,
|
||
policy_result: 'accepted',
|
||
recorded_at: recordedAt,
|
||
entrypoint: body.entrypoint ?? null,
|
||
actor: body.actor ?? null,
|
||
};
|
||
const routeCommand = buildGovernanceCommandForRouteDecision(decision, body, snapshot);
|
||
const command = routeCommand.command
|
||
? await handleGovernanceCommand(routeCommand.command, snapshot)
|
||
: null;
|
||
if (command?.accepted && command.command_id) {
|
||
decision.created_command_id = command.command_id;
|
||
decision.reason_codes = uniqueStrings([...decision.reason_codes, 'route_action_mapped']);
|
||
} else if (routeCommand.reasonCode) {
|
||
decision.reason_codes = uniqueStrings([...decision.reason_codes, routeCommand.reasonCode]);
|
||
}
|
||
const bridge = window.QimingClawBridge?.digital;
|
||
const recorded = bridge?.recordRouteDecision
|
||
? await bridge.recordRouteDecision({
|
||
id: decision.id,
|
||
idempotencyKey: body.idempotency_key,
|
||
correlationId,
|
||
routeKind: decision.route_kind,
|
||
intentKind: decision.intent_kind,
|
||
reasonCodes: decision.reason_codes,
|
||
candidateSkills: decision.candidate_skills,
|
||
contextRefs: decision.context_refs,
|
||
createdCommandId: decision.created_command_id,
|
||
createsPlan: decision.creates_plan,
|
||
createsTaskRun: decision.creates_task_run,
|
||
approvalMode: decision.approval_mode,
|
||
policyResult: decision.policy_result,
|
||
entrypoint: decision.entrypoint,
|
||
actor: decision.actor,
|
||
message: `入口路由决策：${decision.route_kind} / ${decision.intent_kind}`,
|
||
envelope: {
|
||
text: body.text ?? null,
|
||
payload: body.payload ?? null,
|
||
attachments: body.attachments ?? [],
|
||
},
|
||
recordedAt,
|
||
})
|
||
: null;
|
||
const routeDecision = recorded ?? decision;
|
||
const resultIds = routeCommandResultIds(command);
|
||
return {
|
||
accepted: true,
|
||
envelope: {
|
||
entrypoint: body.entrypoint ?? 'chat',
|
||
text: body.text ?? null,
|
||
payload: body.payload ?? null,
|
||
attachments: body.attachments ?? [],
|
||
context_refs: contextRefs,
|
||
},
|
||
response_kind: 'route_decision',
|
||
route_decision: routeDecision,
|
||
command,
|
||
created_plan_id: resultIds.createdPlanId,
|
||
created_schedule_id: resultIds.createdScheduleId,
|
||
created_task_ids: resultIds.createdTaskIds,
|
||
created_run_ids: resultIds.createdRunIds,
|
||
projection_name: null,
|
||
projection_payload: null,
|
||
message: command?.command_id
|
||
? `已记录入口路由并映射治理动作：${routeDecision.route_kind} / ${routeDecision.intent_kind}`
|
||
: `已记录入口路由：${routeDecision.route_kind} / ${routeDecision.intent_kind}`,
|
||
};
|
||
}
|
||
|
||
function buildGovernanceCommandForRouteDecision(
|
||
decision: RouteDecisionRecord,
|
||
body: IngressRouteRequest,
|
||
snapshot: QimingclawSnapshot | null,
|
||
): { command: GovernanceCommandRequest | null; reasonCode: string } {
|
||
if (decision.reason_codes.includes('candidate_skills_disabled')) {
|
||
return { command: null, reasonCode: 'route_action_not_mapped' };
|
||
}
|
||
|
||
const contextRefs = decision.context_refs ?? {};
|
||
const payload = asRecord(body.payload) ?? {};
|
||
const basePayload = compactRecord({
|
||
...payload,
|
||
source: 'qimingclaw-ingress-route',
|
||
route_decision_id: decision.id,
|
||
route_kind: decision.route_kind,
|
||
intent_kind: decision.intent_kind,
|
||
reason_codes: decision.reason_codes,
|
||
ingress_text: body.text ?? null,
|
||
});
|
||
const baseCommand = (commandKind: GovernanceCommandRequest['command_kind'], refs: Record<string, unknown>): GovernanceCommandRequest => ({
|
||
command_kind: commandKind,
|
||
context_refs: compactRecord({ ...contextRefs, ...refs }),
|
||
payload: compactRecord({ ...basePayload, ...refs }),
|
||
correlation_id: decision.correlation_id,
|
||
idempotency_key: `route-command:${decision.id}`,
|
||
});
|
||
|
||
if (decision.route_kind === 'PlanExecution' && decision.intent_kind === 'schedule') {
|
||
const scheduleId = stringValue(contextRefs.schedule_id) || stringValue(payload.schedule_id) || stringValue(payload.scheduleId);
|
||
if (!scheduleId) return { command: null, reasonCode: 'route_action_missing_context' };
|
||
return { command: baseCommand('run_schedule_now', { schedule_id: scheduleId }), reasonCode: 'route_action_mapped' };
|
||
}
|
||
|
||
if (decision.route_kind === 'PlanExecution' && decision.intent_kind === 'execute') {
|
||
const stepId = stringValue(contextRefs.step_id) || stringValue(payload.step_id) || stringValue(payload.stepId);
|
||
const taskId = stringValue(contextRefs.task_id) || stringValue(payload.task_id) || stringValue(payload.taskId) || taskIdForRouteStep(snapshot, stepId);
|
||
if (!taskId) return { command: null, reasonCode: 'route_action_missing_context' };
|
||
const task = runtimeTasks(snapshot).find((candidate) => candidate.id === taskId) ?? null;
|
||
return {
|
||
command: baseCommand('start_run', {
|
||
plan_id: stringValue(contextRefs.plan_id) || task?.planId || stringValue(payload.plan_id) || stringValue(payload.planId),
|
||
task_id: taskId,
|
||
step_id: stepId || (task ? taskStepId(task) : ''),
|
||
run_id: stringValue(contextRefs.run_id) || stringValue(payload.run_id) || stringValue(payload.runId),
|
||
}),
|
||
reasonCode: 'route_action_mapped',
|
||
};
|
||
}
|
||
|
||
if (decision.route_kind === 'PlanControl' && decision.intent_kind === 'control') {
|
||
const actionText = routeActionText(body);
|
||
const taskId = stringValue(contextRefs.task_id) || stringValue(payload.task_id) || stringValue(payload.taskId);
|
||
const planId = stringValue(contextRefs.plan_id) || stringValue(payload.plan_id) || stringValue(payload.planId);
|
||
const commandKind = routeControlCommandKind(actionText, Boolean(taskId));
|
||
if (!commandKind || (!taskId && !planId)) return { command: null, reasonCode: 'route_action_missing_context' };
|
||
return {
|
||
command: baseCommand(commandKind, {
|
||
plan_id: planId,
|
||
task_id: taskId,
|
||
step_id: stringValue(contextRefs.step_id) || stringValue(payload.step_id) || stringValue(payload.stepId),
|
||
run_id: stringValue(contextRefs.run_id) || stringValue(payload.run_id) || stringValue(payload.runId),
|
||
}),
|
||
reasonCode: 'route_action_mapped',
|
||
};
|
||
}
|
||
|
||
return { command: null, reasonCode: 'route_action_not_mapped' };
|
||
}
|
||
|
||
function taskIdForRouteStep(snapshot: QimingclawSnapshot | null, stepId: string): string {
|
||
if (!stepId) return '';
|
||
const ready = runtimePlanSteps(snapshot).some((step) => step.id === stepId && step.status.toLowerCase() === 'ready');
|
||
if (!ready) return '';
|
||
return runtimeTasks(snapshot).find((task) => taskStepId(task) === stepId)?.id ?? '';
|
||
}
|
||
|
||
function routeActionText(body: IngressRouteRequest): string {
|
||
const payload = asRecord(body.payload) ?? {};
|
||
return [body.text, payload.action, payload.command, payload.intent, payload.requested_action]
|
||
.map(stringValue)
|
||
.filter(Boolean)
|
||
.join(' ')
|
||
.toLowerCase();
|
||
}
|
||
|
||
function routeControlCommandKind(actionText: string, hasTaskTarget: boolean): GovernanceCommandRequest['command_kind'] | null {
|
||
if (hasTaskTarget) {
|
||
if (matchesRouteText(actionText, ['retry', '重试'])) return 'retry_task';
|
||
if (matchesRouteText(actionText, ['skip', '跳过'])) return 'skip_task';
|
||
if (matchesRouteText(actionText, ['pause', '暂停'])) return 'pause_task';
|
||
if (matchesRouteText(actionText, ['resume', '恢复'])) return 'resume_task';
|
||
if (matchesRouteText(actionText, ['cancel', '取消'])) return 'cancel_task';
|
||
if (matchesRouteText(actionText, ['start', 'run', 'execute', 'begin', '启动', '开始', '执行'])) return 'start_run';
|
||
return null;
|
||
}
|
||
if (matchesRouteText(actionText, ['submit', '提交'])) return 'submit_plan';
|
||
if (matchesRouteText(actionText, ['approve', '批准', '同意'])) return 'approve_plan';
|
||
if (matchesRouteText(actionText, ['pause', '暂停'])) return 'pause_plan';
|
||
if (matchesRouteText(actionText, ['resume', '恢复'])) return 'resume_plan';
|
||
if (matchesRouteText(actionText, ['cancel', '取消'])) return 'cancel_plan';
|
||
if (matchesRouteText(actionText, ['amend', 'edit', 'revise', '修改', '调整'])) return 'amend_plan';
|
||
if (matchesRouteText(actionText, ['activate', 'start', 'run', 'execute', '启动', '开始', '执行'])) return 'activate_plan';
|
||
return null;
|
||
}
|
||
|
||
function routeCommandResultIds(command: GovernanceCommandResponse | null): {
|
||
createdPlanId: string | null;
|
||
createdScheduleId: string | null;
|
||
createdTaskIds: string[];
|
||
createdRunIds: string[];
|
||
} {
|
||
const result = asRecord(command?.result) ?? {};
|
||
const createdTaskIds = uniqueStrings([
|
||
result.task_id,
|
||
result.taskId,
|
||
...arrayValue(result.dispatched_tasks).map((task) => asRecord(task)?.task_id ?? asRecord(task)?.taskId),
|
||
]);
|
||
return {
|
||
createdPlanId: stringValue(result.plan_id) || stringValue(result.planId) || null,
|
||
createdScheduleId: stringValue(result.schedule_id) || stringValue(result.scheduleId) || null,
|
||
createdTaskIds,
|
||
createdRunIds: uniqueStrings([result.run_id, result.runId]),
|
||
};
|
||
}
|
||
|
||
function buildIngressContextRefs(body: IngressRouteRequest): Record<string, unknown> {
|
||
const payload = asRecord(body.payload) ?? {};
|
||
const context = asRecord(body.context_refs) ?? {};
|
||
return compactRecord({
|
||
...context,
|
||
entrypoint: body.entrypoint ?? context.entrypoint,
|
||
plan_id: stringValue(context.plan_id) || stringValue(payload.plan_id) || stringValue(payload.planId),
|
||
task_id: stringValue(context.task_id) || stringValue(payload.task_id) || stringValue(payload.taskId),
|
||
run_id: stringValue(context.run_id) || stringValue(payload.run_id) || stringValue(payload.runId),
|
||
step_id: stringValue(context.step_id) || stringValue(payload.step_id) || stringValue(payload.stepId),
|
||
schedule_id: stringValue(context.schedule_id) || stringValue(payload.schedule_id) || stringValue(payload.scheduleId),
|
||
});
|
||
}
|
||
|
||
function classifyIngressRoute(
|
||
body: IngressRouteRequest,
|
||
contextRefs: Record<string, unknown>,
|
||
snapshot: QimingclawSnapshot | null,
|
||
): { routeKind: string; intentKind: string; reasonCodes: string[]; candidateSkills: string[]; createsPlan: boolean; createsTaskRun: boolean } {
|
||
const payload = asRecord(body.payload) ?? {};
|
||
const text = `${body.text ?? ''} ${stringValue(payload.action)} ${stringValue(payload.command)} ${stringValue(payload.intent)}`.toLowerCase();
|
||
const hasPayload = Object.keys(payload).length > 0;
|
||
const hasContext = ['plan_id', 'task_id', 'step_id', 'schedule_id'].some((key) => Boolean(stringValue(contextRefs[key])));
|
||
const stepId = stringValue(contextRefs.step_id);
|
||
const readyStep = stepId && runtimePlanSteps(snapshot).some((step) => step.id === stepId && step.status.toLowerCase() === 'ready');
|
||
|
||
if (hasContext && matchesRouteText(text, ['start', 'run', 'retry', 'skip', 'cancel', 'pause', 'resume', 'approve', '启动', '开始', '执行', '重试', '跳过', '取消', '暂停', '恢复', '批准'])) {
|
||
return routeClassification('PlanControl', 'control', ['context_control_action'], contextRefs, payload, false, false);
|
||
}
|
||
if (body.entrypoint === 'cron' || matchesRouteText(text, ['cron', 'schedule', 'scheduled', '定时', '调度', '周期'])) {
|
||
return routeClassification('PlanExecution', 'schedule', ['scheduled_entrypoint'], contextRefs, payload, false, true);
|
||
}
|
||
if (matchesRouteText(text, ['status', 'progress', 'result', 'report', 'artifact', 'memory', '状态', '进度', '结果', '日报', '产物', '记忆'])) {
|
||
return routeClassification('ProjectionQuery', 'query', ['projection_query_text'], contextRefs, payload, false, false);
|
||
}
|
||
if (readyStep || matchesRouteText(text, ['execute', 'dispatch', 'delegate', 'run task', '执行', '开始', '委托', '派发'])) {
|
||
return routeClassification('PlanExecution', 'execute', readyStep ? ['ready_step_context'] : ['execution_text'], contextRefs, payload, false, true);
|
||
}
|
||
if (!body.text && !hasPayload && !hasContext) {
|
||
return routeClassification('AskClarification', 'chat', ['empty_ingress'], contextRefs, payload, false, false);
|
||
}
|
||
return routeClassification('ChatOnly', 'chat', ['default_chat'], contextRefs, payload, false, false);
|
||
}
|
||
|
||
function routeClassification(
|
||
routeKind: string,
|
||
intentKind: string,
|
||
reasonCodes: string[],
|
||
contextRefs: Record<string, unknown>,
|
||
payload: Record<string, unknown>,
|
||
createsPlan: boolean,
|
||
createsTaskRun: boolean,
|
||
): { routeKind: string; intentKind: string; reasonCodes: string[]; candidateSkills: string[]; createsPlan: boolean; createsTaskRun: boolean } {
|
||
return {
|
||
routeKind,
|
||
intentKind,
|
||
reasonCodes,
|
||
candidateSkills: routeCandidateSkills(routeKind, contextRefs, payload),
|
||
createsPlan,
|
||
createsTaskRun,
|
||
};
|
||
}
|
||
|
||
function routeCandidateSkills(routeKind: string, contextRefs: Record<string, unknown>, payload: Record<string, unknown>): string[] {
|
||
const explicit = uniqueStrings([
|
||
...arrayValue(contextRefs.skill_ids),
|
||
...arrayValue(contextRefs.skills),
|
||
...arrayValue(contextRefs.candidate_skills),
|
||
...arrayValue(payload.skill_ids),
|
||
...arrayValue(payload.skills),
|
||
...arrayValue(payload.candidate_skills),
|
||
stringValue(contextRefs.skill_id),
|
||
stringValue(payload.skill_id),
|
||
]);
|
||
if (explicit.length > 0) return explicit;
|
||
if (routeKind === 'PlanControl') return ['qimingclaw-acp-session'];
|
||
if (routeKind === 'ProjectionQuery') return ['qimingclaw-artifact-reporting'];
|
||
if (routeKind === 'PlanExecution') return ['qimingclaw-computer-control'];
|
||
return [];
|
||
}
|
||
|
||
async function filterRouteCandidateSkills(
|
||
candidateSkills: string[],
|
||
): Promise<{ candidateSkills: string[]; allCandidatesDisabled: boolean }> {
|
||
if (candidateSkills.length === 0) {
|
||
return { candidateSkills, allCandidatesDisabled: false };
|
||
}
|
||
const bridge = window.QimingClawBridge?.digital;
|
||
if (!bridge?.getSkillCapabilities) {
|
||
return { candidateSkills, allCandidatesDisabled: false };
|
||
}
|
||
try {
|
||
const result = await bridge.getSkillCapabilities();
|
||
if (!Array.isArray(result?.skills)) {
|
||
return { candidateSkills, allCandidatesDisabled: false };
|
||
}
|
||
const enabledBySkillId = new Map<string, boolean>();
|
||
for (const skill of result.skills) {
|
||
const skillId = stringValue(skill.skill_id);
|
||
if (skillId) enabledBySkillId.set(skillId, skill.enabled !== false);
|
||
}
|
||
const enabledCandidates = candidateSkills.filter((skillId) => enabledBySkillId.get(skillId) !== false);
|
||
return {
|
||
candidateSkills: enabledCandidates,
|
||
allCandidatesDisabled: candidateSkills.length > 0 && enabledCandidates.length === 0,
|
||
};
|
||
} catch (error) {
|
||
console.warn('[qimingclawAdapter] filter route candidate skills failed:', error);
|
||
return { candidateSkills, allCandidatesDisabled: false };
|
||
}
|
||
}
|
||
|
||
function uniqueStrings(values: unknown[]): string[] {
|
||
return [...new Set(values.map(stringValue).filter(Boolean))];
|
||
}
|
||
|
||
function matchesRouteText(text: string, keywords: string[]): boolean {
|
||
return keywords.some((keyword) => text.includes(keyword.toLowerCase()));
|
||
}
|
||
|
||
function compactRecord(record: Record<string, unknown>): Record<string, unknown> {
|
||
return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined && value !== null && value !== ''));
|
||
}
|
||
|
||
async function handleGovernanceCommand(
|
||
body: GovernanceCommandRequest,
|
||
snapshot: QimingclawSnapshot | null,
|
||
): Promise<GovernanceCommandResponse> {
|
||
const commandId = `qimingclaw-digital-${body.command_kind}-${Date.now()}`;
|
||
const correlationId = body.correlation_id || commandId;
|
||
const planId = stringFromUnknown(body.context_refs?.plan_id)
|
||
|| stringFromUnknown(body.payload?.plan_id)
|
||
|| stringFromUnknown(body.payload?.original_plan_id);
|
||
const taskId = stringFromUnknown(body.context_refs?.task_id)
|
||
|| stringFromUnknown(body.payload?.task_id)
|
||
|| stringFromUnknown(body.payload?.original_task_id);
|
||
const runId = stringFromUnknown(body.context_refs?.run_id)
|
||
|| stringFromUnknown(body.payload?.run_id)
|
||
|| stringFromUnknown(body.payload?.latest_run_id);
|
||
const stepId = stringFromUnknown(body.context_refs?.step_id)
|
||
|| stringFromUnknown(body.payload?.step_id)
|
||
|| stringFromUnknown(body.payload?.stepId);
|
||
const scheduleId = stringFromUnknown(body.context_refs?.schedule_id)
|
||
|| stringFromUnknown(body.payload?.schedule_id);
|
||
|
||
if (body.command_kind === 'create_plan') {
|
||
const createdPlanId = `qimingclaw-local-${slugifyIdPart(stringFromUnknown(body.payload?.title) || planId || 'plan')}-${Date.now()}`;
|
||
const response = governanceAccepted(commandId, correlationId, '已在 qimingclaw 兼容层创建本地计划草稿。', {
|
||
plan_id: createdPlanId,
|
||
status: 'draft',
|
||
source: 'qimingclaw-adapter',
|
||
requested_action: body.payload?.requested_action,
|
||
original_plan_id: body.payload?.original_plan_id ?? planId,
|
||
});
|
||
await recordGovernanceCommand(body, response);
|
||
return response;
|
||
}
|
||
|
||
if (body.command_kind === 'activate_plan' || body.command_kind === 'run_schedule_now') {
|
||
const targetPlanId = planId || runtimeDebugPlans(snapshot)[0]?.plan_id || templatePlans(snapshot)[0]?.plan_id || 'qimingclaw-client-readiness';
|
||
const dispatch = await dispatchPlan(targetPlanId, snapshot, { recordCommand: false });
|
||
const response = governanceAccepted(commandId, correlationId, '已映射为 qimingclaw 本地任务激活。', {
|
||
plan_id: targetPlanId,
|
||
schedule_id: body.command_kind === 'run_schedule_now' ? scheduleId : null,
|
||
status: 'active',
|
||
dispatched_tasks: dispatch.dispatched_tasks,
|
||
source: 'qimingclaw-adapter',
|
||
});
|
||
await recordGovernanceCommand(body, response);
|
||
return response;
|
||
}
|
||
|
||
if (body.command_kind === 'create_schedule') {
|
||
const response = governanceAccepted(commandId, correlationId, '已记录 qimingclaw 兼容定时任务请求。', {
|
||
schedule_id: scheduleId || `qimingclaw-schedule-${Date.now()}`,
|
||
plan_id: planId,
|
||
status: 'enabled',
|
||
source: 'qimingclaw-adapter',
|
||
});
|
||
await recordGovernanceCommand(body, response);
|
||
return response;
|
||
}
|
||
|
||
if (['update_schedule', 'pause_schedule', 'resume_schedule', 'delete_schedule'].includes(body.command_kind)) {
|
||
const status = body.command_kind === 'pause_schedule'
|
||
? 'paused'
|
||
: body.command_kind === 'delete_schedule'
|
||
? 'deleted'
|
||
: 'enabled';
|
||
const response = governanceAccepted(commandId, correlationId, `已接受 ${body.command_kind}，并更新 qimingclaw 本地定时任务状态。`, {
|
||
schedule_id: scheduleId || `qimingclaw-schedule-${Date.now()}`,
|
||
plan_id: planId,
|
||
status,
|
||
source: 'qimingclaw-adapter',
|
||
});
|
||
await recordGovernanceCommand(body, response);
|
||
return response;
|
||
}
|
||
|
||
if (['submit_plan', 'approve_plan', 'amend_plan', 'resume_plan', 'pause_plan', 'cancel_plan'].includes(body.command_kind)) {
|
||
const response = governanceAccepted(commandId, correlationId, `已接受 ${body.command_kind}，当前由 qimingclaw 本地 adapter 记录兼容状态。`, {
|
||
plan_id: planId,
|
||
status: body.command_kind === 'approve_plan'
|
||
? 'approved'
|
||
: body.command_kind === 'submit_plan'
|
||
? 'reviewing'
|
||
: 'accepted',
|
||
source: 'qimingclaw-adapter',
|
||
});
|
||
await recordGovernanceCommand(body, response);
|
||
return response;
|
||
}
|
||
|
||
if (['retry_task', 'skip_task', 'pause_task', 'resume_task', 'provide_task_input', 'cancel_task', 'start_run', 'cancel_run'].includes(body.command_kind)) {
|
||
const targetTask = taskId || runtimeTasks(snapshot)[0]?.id || 'qimingclaw-task-agent';
|
||
const runtimeTask = runtimeTasks(snapshot).find((task) => task.id === targetTask);
|
||
const targetRunId = runId || latestRunForTask(runtimeRuns(snapshot), targetTask)?.id || null;
|
||
const targetStepId = stepId || (runtimeTask ? taskStepId(runtimeTask) : null);
|
||
const response = governanceAccepted(commandId, correlationId, `已接受 ${body.command_kind}，并记录到 qimingclaw Task Agent 控制平面。`, {
|
||
plan_id: planId || runtimeTask?.planId || 'qimingclaw-task-agent-plan',
|
||
task_id: targetTask,
|
||
run_id: targetRunId,
|
||
step_id: targetStepId,
|
||
task_agent_id: `task-agent-${slugifyIdPart(targetTask)}`,
|
||
status: taskGovernanceStatus(body.command_kind),
|
||
next_action: taskGovernanceNextAction(body.command_kind),
|
||
source: 'qimingclaw-task-agent',
|
||
});
|
||
await recordGovernanceCommand(body, response);
|
||
return response;
|
||
}
|
||
|
||
const response = {
|
||
command_id: commandId,
|
||
accepted: false,
|
||
correlation_id: correlationId,
|
||
error: 'missing_capability',
|
||
message: `qimingclaw 数字员工兼容层尚未支持 ${body.command_kind}。`,
|
||
};
|
||
await recordGovernanceCommand(body, response);
|
||
return response;
|
||
}
|
||
|
||
function governanceAccepted(
|
||
commandId: string,
|
||
correlationId: string,
|
||
message: string,
|
||
result: Record<string, unknown>,
|
||
): GovernanceCommandResponse {
|
||
return {
|
||
command_id: commandId,
|
||
accepted: true,
|
||
correlation_id: correlationId,
|
||
message,
|
||
result,
|
||
};
|
||
}
|
||
|
||
function taskGovernanceStatus(commandKind: string): string {
|
||
switch (commandKind) {
|
||
case 'retry_task':
|
||
case 'start_run':
|
||
case 'resume_task':
|
||
return 'running';
|
||
case 'skip_task':
|
||
return 'skipped';
|
||
case 'cancel_task':
|
||
case 'cancel_run':
|
||
return 'cancelled';
|
||
case 'pause_task':
|
||
return 'paused';
|
||
default:
|
||
return 'accepted';
|
||
}
|
||
}
|
||
|
||
function taskGovernanceNextAction(commandKind: string): string {
|
||
switch (commandKind) {
|
||
case 'retry_task':
|
||
return 'start_retry_run';
|
||
case 'skip_task':
|
||
return 'continue_next_task';
|
||
case 'pause_task':
|
||
return 'await_resume';
|
||
case 'resume_task':
|
||
return 'watch_progress';
|
||
case 'provide_task_input':
|
||
return 'resume_with_input';
|
||
case 'cancel_task':
|
||
case 'cancel_run':
|
||
return 'close_execution';
|
||
case 'start_run':
|
||
return 'watch_progress';
|
||
default:
|
||
return 'record_control_event';
|
||
}
|
||
}
|
||
|
||
function stringFromUnknown(value: unknown): string {
|
||
return typeof value === 'string' && value.trim() ? value.trim() : '';
|
||
}
|
||
|
||
function buildPlanFlow(planId: string, snapshot: QimingclawSnapshot | null = null): FlowResponse {
|
||
if (hasRuntimeRecords(snapshot)) {
|
||
const plan = runtimePlans(snapshot).find((candidate) => candidate.id === planId);
|
||
const tasks = buildTasks(planId, snapshot);
|
||
const planSteps = runtimeStepsForPlan(snapshot, planId);
|
||
const runs = buildTasksResponse(planId, snapshot).runs;
|
||
const events = runtimeEvents(snapshot).filter((event) => event.planId === planId || tasks.some((task) => task.task_id === event.taskId));
|
||
const title = plan?.title ?? tasks[0]?.title ?? planId;
|
||
const objective = plan?.objective ?? 'qimingclaw 本地运行记录';
|
||
const qimingclawFlowSteps: FlowResponse['steps'] = [];
|
||
let nextSeq = 2;
|
||
if (planSteps.length > 0) {
|
||
const knownStepIds = new Set(planSteps.map((step) => step.id));
|
||
for (const step of planSteps) {
|
||
qimingclawFlowSteps.push({
|
||
seq: nextSeq++,
|
||
lane: 'qimingclaw',
|
||
label: step.title,
|
||
sub_label: `${taskStatusLabel(step.status)} · 依赖 ${step.dependsOn.length} · 技能 ${step.preferredSkillIds.length}`,
|
||
timestamp: step.updatedAt,
|
||
color: '#22c55e',
|
||
source_type: 'plan_step',
|
||
});
|
||
for (const task of tasks.filter((candidate) => candidate.step_id === step.id)) {
|
||
qimingclawFlowSteps.push(runtimeTaskFlowStep(task, nextSeq++));
|
||
}
|
||
}
|
||
const orphanTasks = tasks.filter((task) => !knownStepIds.has(task.step_id || ''));
|
||
if (orphanTasks.length > 0) {
|
||
qimingclawFlowSteps.push({
|
||
seq: nextSeq++,
|
||
lane: 'qimingclaw',
|
||
label: '未归属步骤',
|
||
sub_label: `包含 ${orphanTasks.length} 个任务`,
|
||
timestamp: orphanTasks[0]?.updated_at ?? new Date().toISOString(),
|
||
color: '#22c55e',
|
||
source_type: 'plan_step',
|
||
});
|
||
for (const task of orphanTasks) qimingclawFlowSteps.push(runtimeTaskFlowStep(task, nextSeq++));
|
||
}
|
||
} else {
|
||
for (const task of tasks) qimingclawFlowSteps.push(runtimeTaskFlowStep(task, nextSeq++));
|
||
}
|
||
return {
|
||
plan_id: planId,
|
||
plan_title: title,
|
||
plan_status: plan ? planRecordStatus(plan, runtimePlanTasks(snapshot, plan.id)) : tasks[0]?.status,
|
||
plan_objective: objective,
|
||
lanes: [
|
||
{ key: 'intent', label: '目标', color: '#38bdf8' },
|
||
{ key: 'qimingclaw', label: 'qimingclaw', color: '#22c55e' },
|
||
{ key: 'execution', label: '执行', color: '#f59e0b' },
|
||
],
|
||
steps: [
|
||
{
|
||
seq: 1,
|
||
lane: 'intent',
|
||
label: title,
|
||
sub_label: objective,
|
||
timestamp: plan?.createdAt ?? tasks[0]?.created_at ?? new Date().toISOString(),
|
||
color: '#38bdf8',
|
||
source_type: 'plan',
|
||
},
|
||
...qimingclawFlowSteps,
|
||
...runs.map((run, index) => ({
|
||
seq: nextSeq + index,
|
||
lane: 'execution',
|
||
label: run.lifecycle || 'Run',
|
||
sub_label: run.run_id,
|
||
timestamp: run.completed_at ?? run.created_at,
|
||
color: '#f59e0b',
|
||
source_type: 'run',
|
||
})),
|
||
],
|
||
events: events.map((event) => ({
|
||
event_id: event.id,
|
||
kind: event.kind,
|
||
occurred_at: event.occurredAt,
|
||
message: event.message,
|
||
})),
|
||
};
|
||
}
|
||
const plan = withRuntimePlan(templatePlans(snapshot).find((candidate) => candidate.plan_id === planId) ?? templatePlans(snapshot)[0]!, snapshot);
|
||
const timestamp = new Date().toISOString();
|
||
return {
|
||
plan_id: plan.plan_id,
|
||
plan_title: plan.title,
|
||
plan_status: plan.status,
|
||
plan_objective: plan.objective,
|
||
lanes: [
|
||
{ key: 'intent', label: '目标', color: '#38bdf8' },
|
||
{ key: 'qimingclaw', label: 'qimingclaw', color: '#22c55e' },
|
||
{ key: 'execution', label: '执行', color: '#f59e0b' },
|
||
],
|
||
steps: [
|
||
{
|
||
seq: 1,
|
||
lane: 'intent',
|
||
label: plan.title,
|
||
sub_label: plan.objective,
|
||
timestamp: plan.created_at,
|
||
color: '#38bdf8',
|
||
source_type: 'plan',
|
||
},
|
||
{
|
||
seq: 2,
|
||
lane: 'qimingclaw',
|
||
label: '接入客户端能力',
|
||
sub_label: 'ACP / MCP / computer server adapter',
|
||
timestamp,
|
||
color: '#22c55e',
|
||
source_type: 'adapter',
|
||
},
|
||
{
|
||
seq: 3,
|
||
lane: 'execution',
|
||
label: plan.status === 'running' ? '已读取 qimingclaw 服务状态' : '等待调度',
|
||
sub_label: planResultText(plan, snapshot),
|
||
timestamp,
|
||
color: '#f59e0b',
|
||
source_type: 'run',
|
||
},
|
||
],
|
||
events: [
|
||
{
|
||
event_id: `${plan.plan_id}-adapter-event`,
|
||
kind: 'qimingclaw_adapter',
|
||
occurred_at: timestamp,
|
||
message: '数字员工页面已通过 qimingclaw adapter 获取数据。',
|
||
},
|
||
],
|
||
};
|
||
}
|
||
|
||
function runtimeTaskFlowStep(task: DebugTask, seq: number): FlowResponse['steps'][number] {
|
||
return {
|
||
seq,
|
||
lane: 'qimingclaw',
|
||
label: task.title,
|
||
sub_label: `${taskStatusLabel(task.status)} · ${task.assigned_skill_id || 'qimingclaw-runtime'}`,
|
||
timestamp: task.updated_at,
|
||
color: '#22c55e',
|
||
source_type: 'task',
|
||
};
|
||
}
|
||
|
||
function buildTaskFlow(taskId: string, snapshot: QimingclawSnapshot | null = null): FlowResponse {
|
||
const task = runtimeTasks(snapshot).find((candidate) => candidate.id === taskId);
|
||
if (!task) {
|
||
return buildPlanFlow(taskId, snapshot);
|
||
}
|
||
const plan = task.planId ? runtimePlans(snapshot).find((candidate) => candidate.id === task.planId) : null;
|
||
const runs = runtimeRuns(snapshot).filter((run) => run.taskId === task.id);
|
||
const events = runtimeEvents(snapshot).filter((event) => event.taskId === task.id || runs.some((run) => run.id === event.runId));
|
||
return {
|
||
plan_id: task.planId ?? task.id,
|
||
plan_title: plan?.title ?? task.title,
|
||
plan_status: task.status,
|
||
plan_objective: plan?.objective ?? 'qimingclaw 本地任务记录',
|
||
lanes: [
|
||
{ key: 'task', label: '任务', color: '#38bdf8' },
|
||
{ key: 'execution', label: '执行', color: '#22c55e' },
|
||
{ key: 'event', label: '事件', color: '#f59e0b' },
|
||
],
|
||
steps: [
|
||
{
|
||
seq: 1,
|
||
lane: 'task',
|
||
label: task.title,
|
||
sub_label: `${taskStatusLabel(task.status)} · ${task.assignedSkillId || 'qimingclaw-runtime'}`,
|
||
timestamp: task.updatedAt,
|
||
color: '#38bdf8',
|
||
source_type: 'task',
|
||
},
|
||
...runs.map((run, index) => ({
|
||
seq: index + 2,
|
||
lane: 'execution',
|
||
label: run.status || 'Run',
|
||
sub_label: run.id,
|
||
timestamp: run.finishedAt ?? run.startedAt ?? run.createdAt,
|
||
color: '#22c55e',
|
||
source_type: 'run',
|
||
})),
|
||
...events.map((event, index) => ({
|
||
seq: runs.length + index + 2,
|
||
lane: 'event',
|
||
label: event.kind,
|
||
sub_label: event.message,
|
||
timestamp: event.occurredAt,
|
||
color: '#f59e0b',
|
||
source_type: 'event',
|
||
})),
|
||
],
|
||
events: events.map((event) => ({
|
||
event_id: event.id,
|
||
kind: event.kind,
|
||
occurred_at: event.occurredAt,
|
||
message: event.message,
|
||
})),
|
||
};
|
||
}
|
||
|
||
async function dispatchPlan(
|
||
planId: string,
|
||
snapshot: QimingclawSnapshot | null = null,
|
||
options: { recordCommand?: boolean } = {},
|
||
): Promise<PlanDispatchResponse> {
|
||
const state = snapshot?.uiState ?? await readBridgeUiState() ?? readState();
|
||
const date = todayInputDate();
|
||
const plan = mergedDebugPlans(snapshot).find((candidate) => candidate.plan_id === planId);
|
||
const activatedAt = Date.now();
|
||
const correlationId = `dispatch-${planId}-${activatedAt}`;
|
||
const selected = new Set(state.selectedDutyIdsByDate[date] ?? []);
|
||
selected.add(planId);
|
||
state.selectedDutyIdsByDate[date] = [...selected];
|
||
state.confirmedDates[date] = state.confirmedDates[date] ?? new Date().toISOString();
|
||
await saveState(state, 'confirm_workday', date);
|
||
const dispatchedTasks = buildTasks(planId, snapshot).map((task) => ({
|
||
task_id: task.task_id,
|
||
title: task.title,
|
||
status: task.status === 'pending' ? 'running' : task.status,
|
||
}));
|
||
if (options.recordCommand !== false) {
|
||
await recordGovernanceCommand(
|
||
{
|
||
command_kind: 'activate_plan',
|
||
context_refs: { plan_id: planId },
|
||
payload: {
|
||
plan_id: planId,
|
||
title: plan?.title,
|
||
objective: plan?.objective,
|
||
requested_action: 'dispatch_plan',
|
||
},
|
||
correlation_id: correlationId,
|
||
},
|
||
governanceAccepted(
|
||
`qimingclaw-digital-dispatch-${slugifyIdPart(planId)}-${activatedAt}`,
|
||
correlationId,
|
||
'已将数字员工模板执行写入 qimingclaw 本地运行记录。',
|
||
{
|
||
plan_id: planId,
|
||
status: 'active',
|
||
dispatched_tasks: dispatchedTasks,
|
||
source: 'qimingclaw-adapter',
|
||
},
|
||
),
|
||
);
|
||
}
|
||
|
||
return {
|
||
ok: true,
|
||
plan_id: planId,
|
||
source_plan_id: planId,
|
||
dispatched_tasks: dispatchedTasks,
|
||
};
|
||
}
|
||
|
||
async function dispatchPlanReadySteps(
|
||
planId: string,
|
||
snapshot: QimingclawSnapshot | null = null,
|
||
): Promise<ReadyStepDispatchResult> {
|
||
const targetPlanId = stringValue(planId);
|
||
const bridgeResult = targetPlanId ? await window.QimingClawBridge?.digital?.dispatchPlanReadySteps?.(targetPlanId).catch(() => null) : null;
|
||
if (bridgeResult) return bridgeResult;
|
||
const now = new Date().toISOString();
|
||
const orchestrationId = `manual-ready-steps-${slugifyIdPart(targetPlanId || 'unknown')}-${slugifyIdPart(now)}`;
|
||
const rows = planStepRows(snapshot).filter((row) => stringValue(row.plan_id) === targetPlanId && stringValue(row.status).toLowerCase() === 'ready');
|
||
const state = notificationAdapterState(snapshot);
|
||
const policy = planStepDispatchPolicy(state);
|
||
const result: ReadyStepDispatchResult = {
|
||
ok: true,
|
||
plan_id: targetPlanId || null,
|
||
trigger_source: 'manual',
|
||
orchestration_id: orchestrationId,
|
||
candidates: rows.length,
|
||
dispatched: 0,
|
||
skipped: 0,
|
||
failed: 0,
|
||
dispatched_step_ids: [],
|
||
skipped_step_ids: [],
|
||
failed_step_ids: [],
|
||
errors: [],
|
||
};
|
||
if (!targetPlanId || !policy.enabled) {
|
||
result.skipped = rows.length;
|
||
result.skipped_step_ids = rows.map((row) => stringValue(row.step_id)).filter(Boolean);
|
||
return result;
|
||
}
|
||
const maxPerSweep = Math.max(1, Math.min(Math.floor(policy.max_per_sweep), 10));
|
||
let attempts = 0;
|
||
for (const row of rows) {
|
||
const stepId = stringValue(row.step_id);
|
||
const taskId = stringValue(row.task_id);
|
||
if (attempts >= maxPerSweep || row.dispatchable !== true || !taskId) {
|
||
result.skipped += 1;
|
||
if (stepId) result.skipped_step_ids?.push(stepId);
|
||
continue;
|
||
}
|
||
attempts += 1;
|
||
try {
|
||
const runId = stringValue(row.latest_run_id) || `${taskId}:run:start_run:${slugifyIdPart(orchestrationId)}`;
|
||
const commandId = `manual-ready-step-${slugifyIdPart(stepId)}-${Date.now()}`;
|
||
await recordGovernanceCommand(
|
||
{
|
||
command_kind: 'start_run',
|
||
context_refs: { plan_id: targetPlanId, task_id: taskId, run_id: runId, step_id: stepId },
|
||
payload: {
|
||
source: 'digital-home-plan-orchestration',
|
||
plan_id: targetPlanId,
|
||
task_id: taskId,
|
||
run_id: runId,
|
||
step_id: stepId,
|
||
trigger_source: 'manual',
|
||
orchestration_id: orchestrationId,
|
||
candidate_count: rows.length,
|
||
},
|
||
correlation_id: commandId,
|
||
},
|
||
governanceAccepted(commandId, commandId, '已手动推进 Ready PlanStep。', {
|
||
plan_id: targetPlanId,
|
||
task_id: taskId,
|
||
run_id: runId,
|
||
step_id: stepId,
|
||
status: 'running',
|
||
trigger_source: 'manual',
|
||
orchestration_id: orchestrationId,
|
||
source: 'qimingclaw-plan-orchestration',
|
||
}),
|
||
);
|
||
result.dispatched += 1;
|
||
if (stepId) result.dispatched_step_ids?.push(stepId);
|
||
} catch (error) {
|
||
result.failed += 1;
|
||
if (stepId) result.failed_step_ids?.push(stepId);
|
||
result.errors?.push({ stepId, error: error instanceof Error ? error.message : 'dispatch failed' });
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
|
||
function buildPlanMessages(planId: string, snapshot: QimingclawSnapshot | null = null): Array<{ role: string; content: string; created_at?: string | null }> {
|
||
const runtimePlan = runtimePlans(snapshot).find((candidate) => candidate.id === planId);
|
||
if (runtimePlan) {
|
||
const events = runtimeEvents(snapshot).filter((event) => event.planId === planId).slice(0, 12);
|
||
return [
|
||
{
|
||
role: 'user',
|
||
content: `查看 qimingclaw 本地任务：${runtimePlan.title}`,
|
||
created_at: runtimePlan.createdAt,
|
||
},
|
||
...events.map((event) => ({
|
||
role: 'assistant',
|
||
content: `${event.kind}：${event.message}`,
|
||
created_at: event.occurredAt,
|
||
})),
|
||
];
|
||
}
|
||
const plan = templatePlans(snapshot).find((candidate) => candidate.plan_id === planId) ?? templatePlans(snapshot)[0]!;
|
||
return [
|
||
{
|
||
role: 'user',
|
||
content: `执行数字员工任务：${plan.title}`,
|
||
created_at: plan.created_at,
|
||
},
|
||
{
|
||
role: 'assistant',
|
||
content: `已接入 qimingclaw adapter。目标：${plan.objective ?? plan.title}`,
|
||
created_at: new Date().toISOString(),
|
||
},
|
||
];
|
||
}
|