2902 lines
108 KiB
TypeScript
2902 lines
108 KiB
TypeScript
import type {
|
||
ApprovalEntry,
|
||
ArtifactEntry,
|
||
CanonicalEvent,
|
||
CronJob,
|
||
CronRun,
|
||
DashboardResponse,
|
||
DebugPlan,
|
||
DebugRun,
|
||
DebugStoreResponse,
|
||
DebugTask,
|
||
DigitalEmployeeDecision,
|
||
DigitalEmployeeDuty,
|
||
DigitalEmployeeManagedService,
|
||
DigitalEmployeePlanAgentState,
|
||
DigitalEmployeeRunDetail,
|
||
DigitalEmployeeTaskAgentState,
|
||
DigitalEmployeeTaskExecutionSummary,
|
||
DigitalEmployeeWorkEvent,
|
||
DigitalEmployeeWorkdayActionRequest,
|
||
DigitalEmployeeWorkdayProjection,
|
||
FlowResponse,
|
||
GovernanceCommandRequest,
|
||
GovernanceCommandResponse,
|
||
PlanDispatchResponse,
|
||
PlanStepSummary,
|
||
SkillSpec,
|
||
} 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>;
|
||
getPlanTemplates?: () => Promise<QimingclawPlanTemplateList>;
|
||
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 }>;
|
||
getScheduleRuns?: (scheduleId: string, limit?: number) => Promise<QimingclawScheduleRunRecord[]>;
|
||
recordGovernanceCommand?: (command: QimingclawGovernanceCommandRecord) => Promise<unknown>;
|
||
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>>;
|
||
consoleRole?: string;
|
||
rolePreferences?: Record<string, unknown>;
|
||
profile: {
|
||
name: string;
|
||
company: string;
|
||
position: string;
|
||
currentStatus: string;
|
||
};
|
||
}
|
||
|
||
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;
|
||
scheduleId?: string | null;
|
||
accepted?: boolean;
|
||
message?: string;
|
||
error?: string | null;
|
||
payload?: Record<string, unknown> | null;
|
||
result?: Record<string, unknown> | null;
|
||
}
|
||
|
||
interface QimingclawRuntimeRecords {
|
||
generatedAt: string;
|
||
plans: QimingclawPlanRecord[];
|
||
planSteps?: QimingclawPlanStepRecord[];
|
||
schedules?: QimingclawScheduleRecord[];
|
||
scheduleRuns?: QimingclawScheduleRunRecord[];
|
||
tasks: QimingclawTaskRecord[];
|
||
runs: QimingclawRunRecord[];
|
||
events: QimingclawEventRecord[];
|
||
artifacts?: QimingclawArtifactRecord[];
|
||
approvals?: QimingclawApprovalRecord[];
|
||
}
|
||
|
||
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 执行',
|
||
},
|
||
};
|
||
|
||
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;
|
||
}
|
||
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' && pathname === '/api/artifact') {
|
||
return { artifacts: buildArtifacts(await readQimingclawSnapshot()) } 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;
|
||
}
|
||
if (method === 'POST' && pathname.startsWith('/api/debug/plan/') && pathname.endsWith('/dispatch')) {
|
||
return await dispatchPlan(decodeURIComponent(pathname.split('/')[4] || ''), await readQimingclawSnapshot()) 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 { ok: true, skill_id: skillId, enabled: body.enabled ?? true } as T;
|
||
}
|
||
|
||
return undefined;
|
||
}
|
||
|
||
function defaultState(): AdapterState {
|
||
return {
|
||
selectedDutyIdsByDate: {},
|
||
confirmedDates: {},
|
||
reportScheduleTime: DEFAULT_REPORT_TIME,
|
||
reportGeneratedAtByDate: {},
|
||
decisionResultsByDate: {},
|
||
consoleRole: 'sales',
|
||
rolePreferences: {},
|
||
profile: {
|
||
name: '飞天数字员工',
|
||
company: 'qimingclaw 客户端',
|
||
position: '客户端任务执行员',
|
||
currentStatus: 'working',
|
||
},
|
||
};
|
||
}
|
||
|
||
function readState(): AdapterState {
|
||
try {
|
||
const raw = window.localStorage.getItem(STATE_KEY);
|
||
return raw ? { ...defaultState(), ...JSON.parse(raw) as Partial<AdapterState> } : defaultState();
|
||
} catch {
|
||
return defaultState();
|
||
}
|
||
}
|
||
|
||
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[]> {
|
||
return dedupeSkills([...SKILLS, ...await readBridgeSkillCapabilities()]);
|
||
}
|
||
|
||
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,
|
||
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 };
|
||
}
|
||
}
|
||
|
||
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 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} 项需处理`;
|
||
}
|
||
|
||
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'].includes(normalized)) return 'danger';
|
||
if (['running', 'active', 'leased', 'syncing'].includes(normalized)) return 'running';
|
||
return 'waiting';
|
||
}
|
||
|
||
function taskStatusLabel(status: string): string {
|
||
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);
|
||
return {
|
||
agent_id: `task-agent-${slugifyIdPart(task.id)}`,
|
||
task_id: task.id,
|
||
plan_id: task.planId ?? null,
|
||
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: tone === 'danger',
|
||
can_skip: tone === 'danger' || tone === 'waiting',
|
||
can_cancel: tone === 'running',
|
||
next_action: tone === 'danger' ? 'retry_or_skip' : tone === 'running' ? 'watch_progress' : tone === 'success' ? 'collect_artifacts' : 'start_run',
|
||
updated_at: latestRun?.updatedAt ?? task.updatedAt,
|
||
};
|
||
});
|
||
}
|
||
|
||
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 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 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 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;
|
||
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) || '待确认任务',
|
||
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,
|
||
})),
|
||
];
|
||
return dedupeArtifacts(artifacts);
|
||
}
|
||
|
||
function artifactFromRuntimeRecord(artifact: QimingclawArtifactRecord): ArtifactEntry {
|
||
const payload = asRecord(artifact.payload);
|
||
return {
|
||
artifact_id: artifact.id,
|
||
subject_id: artifact.runId ?? artifact.taskId ?? artifact.planId ?? artifact.id,
|
||
kind: artifact.kind,
|
||
name: artifact.name || stringValue(payload?.name ?? payload?.title) || artifactName(artifact.uri ?? '') || artifact.kind,
|
||
uri: artifact.uri || stringValue(payload?.uri ?? payload?.url ?? payload?.path) || undefined,
|
||
value: stringValue(payload?.value ?? payload?.summary ?? payload?.text) || artifact.uri || artifact.name || 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: artifactSourceLabel('artifact', artifact.id),
|
||
sync_status: artifact.syncStatus,
|
||
sync_error: artifact.syncError,
|
||
payload: artifact.payload,
|
||
};
|
||
}
|
||
|
||
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 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) || artifactName(uri) || `产物 ${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,
|
||
value: stringValue(record.value ?? record.summary ?? record.text) || uri,
|
||
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: 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,
|
||
};
|
||
}
|
||
|
||
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 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 looksLikeUri(value: string): boolean {
|
||
return /^(file|https?):\/\//i.test(value) || value.includes('/') || value.includes('\\');
|
||
}
|
||
|
||
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 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: buildRunDetails(events),
|
||
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,
|
||
})),
|
||
],
|
||
},
|
||
daily_report: {
|
||
date,
|
||
title: `${displayDate(date)} 飞天数字员工日报`,
|
||
report_schedule_time: state.reportScheduleTime,
|
||
status: generatedAt ? 'ready' : 'not_generated',
|
||
generated_at: generatedAt,
|
||
generated_by: generatedAt ? 'ai' : 'fallback',
|
||
model: 'qimingclaw-adapter',
|
||
source: 'qimingclaw',
|
||
summary: generatedAt
|
||
? `今日已完成数字员工页面到 qimingclaw adapter 的接入，并读取了 qimingclaw 服务状态。${syncLine(snapshot)}。`
|
||
: '日报将在生成后汇总任务选择、运行明细和后续接入建议。',
|
||
totals: {
|
||
task_count: selectedCount,
|
||
execution_count: events.length,
|
||
success_count: successCount,
|
||
failure_count: failureCount,
|
||
running_count: runningCount,
|
||
},
|
||
task_sections: executionSummaries,
|
||
detail_lines: events.map((event) => `${event.time} ${event.task_title}：${event.detail}`),
|
||
artifact_sources: artifactSources,
|
||
pdf_available: Boolean(generatedAt),
|
||
pdf_url: null,
|
||
},
|
||
};
|
||
}
|
||
|
||
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,
|
||
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,
|
||
}));
|
||
}
|
||
|
||
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,
|
||
);
|
||
return buildWorkday(date, { ...(snapshot ?? { generatedAt: new Date().toISOString(), services: {}, sessions: { total: 0, active: 0, items: [] } }), uiState: savedState });
|
||
}
|
||
|
||
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 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 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,
|
||
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 response = governanceAccepted(commandId, correlationId, `已接受 ${body.command_kind}，并记录到 qimingclaw Task Agent 控制平面。`, {
|
||
plan_id: planId || runtimeTasks(snapshot).find((task) => task.id === targetTask)?.planId || 'qimingclaw-task-agent-plan',
|
||
task_id: targetTask,
|
||
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,
|
||
};
|
||
}
|
||
|
||
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(),
|
||
},
|
||
];
|
||
}
|