create-windy 0.1.0

package/template/apps/web/src/pages/system/components/SchedulerOperationsPanel.vue

@@ -0,0 +1,297 @@
+<script setup lang="ts">
+import { computed, shallowRef, type DeepReadonly } from "vue";
+import type {
+  PageResult,
+  SchedulerObservedState,
+  SchedulerOperationsSnapshot,
+  SchedulerOperationsTask,
+  SchedulerRunHistoryItem,
+} from "@windy/shared";
+import { Alert, AlertDescription, AlertTitle } from "@/components/ui/alert";
+import { Badge } from "@/components/ui/badge";
+import { Button } from "@/components/ui/button";
+import {
+  Card,
+  CardContent,
+  CardDescription,
+  CardHeader,
+  CardTitle,
+} from "@/components/ui/card";
+import { PlayIcon, RefreshCwIcon, TriangleAlertIcon } from "@lucide/vue";
+import SchedulerStaleRecoveryForm from "./SchedulerStaleRecoveryForm.vue";
+import { formatDateTime } from "@/lib/date-time";
+import SchedulerRunTable from "./SchedulerRunTable.vue";
+
+interface Props {
+  snapshot?: DeepReadonly<SchedulerOperationsSnapshot>;
+  loading?: boolean;
+  triggeringTaskKey?: string;
+  recoveringRunId?: string;
+  error?: string;
+  resultMessage?: string;
+  runHistory?: DeepReadonly<PageResult<SchedulerRunHistoryItem>>;
+}
+
+interface Emits {
+  refresh: [];
+  trigger: [taskKey: string];
+  recover: [
+    payload: {
+      taskKey: string;
+      runId: string;
+      expectedStartedAt: string;
+      reason: string;
+    },
+  ];
+  "update:run-page": [page: number];
+  "update:run-page-size": [pageSize: number];
+}
+
+const props = withDefaults(defineProps<Props>(), {
+  loading: false,
+  triggeringTaskKey: "",
+  recoveringRunId: "",
+  error: "",
+  resultMessage: "",
+});
+const emit = defineEmits<Emits>();
+const pendingTaskKey = shallowRef("");
+const pendingRecoveryTaskKey = shallowRef("");
+
+const pendingTask = computed(() =>
+  props.snapshot?.tasks.find(
+    ({ definition }) => definition.key === pendingTaskKey.value,
+  ),
+);
+const pendingRecoveryTask = computed(() =>
+  props.snapshot?.tasks.find(
+    ({ definition, latestRun, observability }) =>
+      definition.key === pendingRecoveryTaskKey.value &&
+      observability.stale &&
+      latestRun?.status === "running",
+  ),
+);
+
+const STATE_LABELS: Record<SchedulerObservedState, string> = {
+  idle: "尚未执行",
+  running: "执行中",
+  stale: "疑似停滞",
+  "retry-pending": "等待重试",
+  succeeded: "执行成功",
+  failed: "执行失败",
+  blocked: "已阻断",
+};
+
+function requestTrigger(taskKey: string) {
+  pendingTaskKey.value = taskKey;
+}
+
+function confirmTrigger() {
+  if (!pendingTaskKey.value) return;
+  emit("trigger", pendingTaskKey.value);
+  pendingTaskKey.value = "";
+}
+
+function confirmRecovery(payload: {
+  taskKey: string;
+  runId: string;
+  expectedStartedAt: string;
+  reason: string;
+}) {
+  emit("recover", payload);
+  pendingRecoveryTaskKey.value = "";
+}
+
+function canTrigger(task: DeepReadonly<SchedulerOperationsTask>) {
+  return (
+    task.persistence.enabled &&
+    task.persistence.status === "active" &&
+    !task.observability.stale &&
+    task.observability.state !== "running" &&
+    !props.triggeringTaskKey
+  );
+}
+
+function stateVariant(state: SchedulerObservedState) {
+  if (state === "failed" || state === "stale") return "destructive";
+  if (state === "succeeded") return "default";
+  return "secondary";
+}
+
+function formatDuration(seconds?: number) {
+  if (seconds === undefined) return "—";
+  if (seconds < 60) return `${seconds} 秒`;
+  if (seconds < 3_600) return `${Math.floor(seconds / 60)} 分钟`;
+  return `${Math.floor(seconds / 3_600)} 小时`;
+}
+</script>
+
+<template>
+  <Card>
+    <CardHeader class="gap-3 md:flex-row md:items-center md:justify-between">
+      <div class="space-y-1.5">
+        <CardTitle>定时任务</CardTitle>
+        <CardDescription>
+          展示代码注册定义、数据库状态与最近执行历史；疑似停滞仅提示人工处置。
+        </CardDescription>
+      </div>
+      <Button variant="outline" :disabled="loading" @click="emit('refresh')">
+        <RefreshCwIcon data-icon="inline-start" />
+        刷新任务
+      </Button>
+    </CardHeader>
+    <CardContent class="space-y-4">
+      <Alert v-if="error" variant="destructive">
+        <AlertTitle>调度信息加载失败</AlertTitle>
+        <AlertDescription>{{ error }}</AlertDescription>
+      </Alert>
+      <Alert v-if="resultMessage">
+        <AlertTitle>手动执行结果</AlertTitle>
+        <AlertDescription>{{ resultMessage }}</AlertDescription>
+      </Alert>
+
+      <div v-if="snapshot" class="flex flex-wrap gap-2 text-sm">
+        <Badge variant="outline">任务 {{ snapshot.summary.total }}</Badge>
+        <Badge variant="secondary">运行中 {{ snapshot.summary.running }}</Badge>
+        <Badge variant="secondary">
+          等待重试 {{ snapshot.summary.retryPending }}
+        </Badge>
+        <Badge :variant="snapshot.summary.stale ? 'destructive' : 'outline'">
+          疑似停滞 {{ snapshot.summary.stale }}
+        </Badge>
+      </div>
+
+      <p v-if="loading && !snapshot" class="text-sm text-muted-foreground">
+        正在读取调度器状态…
+      </p>
+      <p
+        v-else-if="!snapshot?.tasks.length"
+        class="rounded-md border border-dashed p-4 text-sm text-muted-foreground"
+      >
+        暂无代码注册的定时任务。
+      </p>
+
+      <div v-else class="grid gap-3 lg:grid-cols-2">
+        <article
+          v-for="task in snapshot?.tasks"
+          :key="task.definition.key"
+          class="space-y-3 rounded-lg border p-4"
+        >
+          <div class="flex items-start justify-between gap-3">
+            <div class="min-w-0 space-y-1">
+              <h3 class="font-medium">{{ task.definition.label }}</h3>
+              <p class="break-all text-xs text-muted-foreground">
+                {{ task.definition.key }} · 代码注册
+              </p>
+            </div>
+            <Badge :variant="stateVariant(task.observability.state)">
+              {{ STATE_LABELS[task.observability.state] }}
+            </Badge>
+          </div>
+
+          <p class="text-sm text-muted-foreground">
+            {{ task.definition.description || "暂无任务说明" }}
+          </p>
+          <dl class="grid grid-cols-2 gap-2 text-xs">
+            <div>
+              <dt class="text-muted-foreground">下次执行</dt>
+              <dd class="mt-1 font-medium">
+                {{ formatDateTime(task.persistence.nextRunAt) }}
+              </dd>
+            </div>
+            <div>
+              <dt class="text-muted-foreground">最近执行</dt>
+              <dd class="mt-1 font-medium">
+                {{ formatDateTime(task.latestRun?.startedAt) }}
+              </dd>
+            </div>
+            <div>
+              <dt class="text-muted-foreground">运行间隔</dt>
+              <dd class="mt-1 font-medium">
+                {{ formatDuration(task.definition.intervalSeconds) }}
+              </dd>
+            </div>
+            <div>
+              <dt class="text-muted-foreground">失败重试</dt>
+              <dd class="mt-1 font-medium">
+                {{ task.observability.retryPendingCount }} / 最多
+                {{ task.definition.maxAttempts }} 次
+              </dd>
+            </div>
+          </dl>
+
+          <Alert v-if="task.observability.stale" variant="destructive">
+            <TriangleAlertIcon />
+            <AlertTitle>执行记录疑似停滞</AlertTitle>
+            <AlertDescription>
+              已运行
+              {{
+                formatDuration(task.observability.runningSeconds)
+              }}，系统不会自动抢占；请人工核查进程与数据库记录。
+            </AlertDescription>
+            <Button
+              v-if="task.latestRun?.status === 'running'"
+              class="mt-3"
+              size="sm"
+              variant="destructive"
+              :disabled="Boolean(recoveringRunId)"
+              @click="pendingRecoveryTaskKey = task.definition.key"
+            >
+              {{
+                recoveringRunId === task.latestRun.id
+                  ? "正在恢复…"
+                  : "人工确认恢复"
+              }}
+            </Button>
+          </Alert>
+          <p
+            v-if="task.latestRun?.errorSummary"
+            class="break-words rounded-md bg-muted p-2 text-xs text-destructive"
+          >
+            错误摘要：{{ task.latestRun.errorSummary }}
+          </p>
+
+          <Button
+            size="sm"
+            :disabled="!canTrigger(task)"
+            @click="requestTrigger(task.definition.key)"
+          >
+            <PlayIcon data-icon="inline-start" />
+            {{
+              triggeringTaskKey === task.definition.key ? "执行中…" : "立即执行"
+            }}
+          </Button>
+        </article>
+      </div>
+
+      <Alert v-if="pendingTask">
+        <AlertTitle>确认手动执行</AlertTitle>
+        <AlertDescription>
+          即将执行「{{ pendingTask.definition.label }}」。任务仍会经过
+          License、Entitlement、Feature 与 RBAC 校验。
+        </AlertDescription>
+        <div class="mt-3 flex gap-2">
+          <Button size="sm" @click="confirmTrigger">确认执行</Button>
+          <Button size="sm" variant="outline" @click="pendingTaskKey = ''">
+            取消
+          </Button>
+        </div>
+      </Alert>
+
+      <SchedulerStaleRecoveryForm
+        v-if="pendingRecoveryTask"
+        :task="pendingRecoveryTask"
+        :recovering="recoveringRunId === pendingRecoveryTask.latestRun?.id"
+        @cancel="pendingRecoveryTaskKey = ''"
+        @recover="confirmRecovery"
+      />
+
+      <SchedulerRunTable
+        :history="runHistory"
+        :loading="loading"
+        @update:page="emit('update:run-page', $event)"
+        @update:page-size="emit('update:run-page-size', $event)"
+      />
+    </CardContent>
+  </Card>
+</template>

package/template/apps/web/src/pages/system/components/SchedulerOperationsPanel.webtest.ts

@@ -0,0 +1,145 @@
+import { flushPromises, mount } from "@vue/test-utils";
+import { describe, expect, test } from "vitest";
+import type { SchedulerOperationsSnapshot } from "@windy/shared";
+import SchedulerOperationsPanel from "./SchedulerOperationsPanel.vue";
+
+describe("SchedulerOperationsPanel", () => {
+  test("用户确认后才发出手动执行事件", async () => {
+    const wrapper = mount(SchedulerOperationsPanel, {
+      props: { snapshot: schedulerSnapshot() },
+    });
+
+    expect(wrapper.text()).toContain("调度器健康快照");
+    expect(wrapper.text()).toContain("代码注册");
+    expect(wrapper.text()).not.toContain("确认手动执行");
+    expect(wrapper.text()).not.toContain("人工确认恢复");
+
+    const triggerButton = wrapper
+      .findAll("button")
+      .find((button) => button.text().includes("立即执行"));
+    expect(triggerButton).toBeDefined();
+    await triggerButton!.trigger("click");
+    await flushPromises();
+
+    expect(wrapper.text()).toContain("确认手动执行");
+    expect(wrapper.emitted("trigger")).toBeUndefined();
+
+    const confirmButton = wrapper
+      .findAll("button")
+      .find((button) => button.text().includes("确认执行"));
+    await confirmButton!.trigger("click");
+    await flushPromises();
+
+    expect(wrapper.emitted("trigger")).toEqual([
+      ["system.scheduler.health-snapshot"],
+    ]);
+  });
+
+  test("展示 stale 人工处置提示、脱敏错误和最近历史", () => {
+    const snapshot = schedulerSnapshot();
+    snapshot.summary.stale = 1;
+    snapshot.tasks[0]!.observability = {
+      ...snapshot.tasks[0]!.observability,
+      state: "stale",
+      stale: true,
+      runningSeconds: 1_200,
+    };
+    snapshot.tasks[0]!.latestRun = {
+      ...snapshot.recentRuns[0]!,
+      status: "running",
+      errorSummary: "token=[REDACTED]",
+    };
+    const wrapper = mount(SchedulerOperationsPanel, {
+      props: { snapshot, resultMessage: "任务执行成功。" },
+    });
+
+    expect(wrapper.text()).toContain("疑似停滞");
+    expect(wrapper.text()).toContain("系统不会自动抢占");
+    expect(wrapper.text()).toContain("人工确认恢复");
+    expect(wrapper.text()).toContain("token=[REDACTED]");
+    expect(wrapper.text()).toContain("最近执行历史");
+    expect(wrapper.text()).toContain("任务执行成功");
+  });
+
+  test("概览不再 stale 时关闭未提交的恢复确认框", async () => {
+    const snapshot = schedulerSnapshot();
+    snapshot.summary.stale = 1;
+    snapshot.tasks[0]!.observability = {
+      ...snapshot.tasks[0]!.observability,
+      state: "stale",
+      stale: true,
+      runningSeconds: 1_200,
+    };
+    snapshot.tasks[0]!.latestRun = {
+      ...snapshot.recentRuns[0]!,
+      status: "running",
+    };
+    const wrapper = mount(SchedulerOperationsPanel, { props: { snapshot } });
+
+    const recover = wrapper
+      .findAll("button")
+      .find((button) => button.text().includes("人工确认恢复"));
+    expect(recover).toBeDefined();
+    await recover!.trigger("click");
+    await flushPromises();
+    expect(document.body.textContent).toContain("确认终结此执行");
+
+    await wrapper.setProps({ snapshot: schedulerSnapshot() });
+    await flushPromises();
+    expect(document.body.textContent).not.toContain("确认终结此执行");
+    wrapper.unmount();
+  });
+});
+
+function schedulerSnapshot(): SchedulerOperationsSnapshot {
+  const run = {
+    id: "run_1",
+    taskKey: "system.scheduler.health-snapshot",
+    trigger: "manual" as const,
+    status: "succeeded" as const,
+    attempt: 1,
+    requestedBy: "user_dev_admin",
+    scheduledFor: "2026-07-10T00:00:00.000Z",
+    startedAt: "2026-07-10T00:00:00.000Z",
+    finishedAt: "2026-07-10T00:00:01.000Z",
+  };
+  return {
+    generatedAt: "2026-07-10T00:00:02.000Z",
+    source: "scheduler",
+    stalePolicy: {
+      mode: "observe-only",
+      thresholdSeconds: 900,
+      action: "manual-intervention",
+    },
+    summary: { total: 1, running: 0, stale: 0, retryPending: 0, failed: 0 },
+    tasks: [
+      {
+        definition: {
+          source: "code-registered",
+          key: "system.scheduler.health-snapshot",
+          label: "调度器健康快照",
+          description: "验证调度器链路。",
+          featureKey: "system.scheduler",
+          permissionKey: "system.scheduler.manage",
+          intervalSeconds: 300,
+          maxAttempts: 3,
+          retryDelaySeconds: 30,
+        },
+        persistence: {
+          enabled: true,
+          status: "active",
+          nextRunAt: "2026-07-10T00:05:00.000Z",
+          lastRunAt: "2026-07-10T00:00:00.000Z",
+        },
+        observability: {
+          state: "succeeded",
+          stale: false,
+          staleThresholdSeconds: 900,
+          retryPendingCount: 0,
+        },
+        latestRun: run,
+      },
+    ],
+    recentRuns: [run],
+  };
+}

package/template/apps/web/src/pages/system/components/SchedulerRunTable.vue

@@ -0,0 +1,127 @@
+<script setup lang="ts">
+import type { DeepReadonly } from "vue";
+import type {
+  PageResult,
+  SchedulerRunHistoryItem,
+  SchedulerRunStatus,
+  SchedulerRunTrigger,
+} from "@windy/shared";
+import DataPagination from "@/components/common/DataPagination.vue";
+import { Badge } from "@/components/ui/badge";
+import { Skeleton } from "@/components/ui/skeleton";
+import {
+  Table,
+  TableBody,
+  TableCell,
+  TableHead,
+  TableHeader,
+  TableRow,
+} from "@/components/ui/table";
+import {
+  Tooltip,
+  TooltipContent,
+  TooltipProvider,
+  TooltipTrigger,
+} from "@/components/ui/tooltip";
+import { formatDateTime } from "@/lib/date-time";
+
+defineProps<{
+  history?: DeepReadonly<PageResult<SchedulerRunHistoryItem>>;
+  loading?: boolean;
+}>();
+
+const emit = defineEmits<{
+  "update:page": [page: number];
+  "update:page-size": [pageSize: number];
+}>();
+
+const TRIGGER_LABELS: Record<SchedulerRunTrigger, string> = {
+  scheduled: "定时",
+  manual: "手动",
+  retry: "重试",
+};
+const STATUS_LABELS: Record<SchedulerRunStatus, string> = {
+  running: "执行中",
+  succeeded: "成功",
+  "retry-pending": "等待重试",
+  failed: "失败",
+  blocked: "阻断",
+};
+</script>
+
+<template>
+  <section class="space-y-3">
+    <h3 class="text-sm font-medium">最近执行历史</h3>
+    <TooltipProvider :delay-duration="0">
+      <div class="overflow-hidden rounded-md border">
+        <Table>
+          <TableHeader>
+            <TableRow>
+              <TableHead class="w-16">序号</TableHead>
+              <TableHead>任务名称</TableHead>
+              <TableHead>触发方式</TableHead>
+              <TableHead>结果</TableHead>
+              <TableHead>次数</TableHead>
+              <TableHead>开始时间</TableHead>
+            </TableRow>
+          </TableHeader>
+          <TableBody>
+            <template v-if="loading && !history?.items.length">
+              <TableRow v-for="row in 3" :key="row">
+                <TableCell v-for="column in 6" :key="column">
+                  <Skeleton class="h-4 w-full max-w-24" />
+                </TableCell>
+              </TableRow>
+            </template>
+            <TableRow v-else-if="!history?.items.length">
+              <TableCell
+                colspan="6"
+                class="h-20 text-center text-muted-foreground"
+              >
+                暂无执行记录。
+              </TableCell>
+            </TableRow>
+            <TableRow
+              v-for="(run, index) in history?.items"
+              v-else
+              :key="run.id"
+            >
+              <TableCell>
+                {{ (history!.page - 1) * history!.pageSize + index + 1 }}
+              </TableCell>
+              <TableCell>
+                <Tooltip>
+                  <TooltipTrigger as-child>
+                    <button
+                      type="button"
+                      class="cursor-help text-left font-medium underline decoration-dotted underline-offset-4"
+                    >
+                      {{ run.taskLabel }}
+                    </button>
+                  </TooltipTrigger>
+                  <TooltipContent>Key：{{ run.taskKey }}</TooltipContent>
+                </Tooltip>
+              </TableCell>
+              <TableCell>{{ TRIGGER_LABELS[run.trigger] }}</TableCell>
+              <TableCell>
+                <Badge variant="secondary">{{
+                  STATUS_LABELS[run.status]
+                }}</Badge>
+              </TableCell>
+              <TableCell>第 {{ run.attempt }} 次</TableCell>
+              <TableCell>{{ formatDateTime(run.startedAt) }}</TableCell>
+            </TableRow>
+          </TableBody>
+        </Table>
+      </div>
+    </TooltipProvider>
+    <DataPagination
+      v-if="history"
+      :page="history.page"
+      :page-size="history.pageSize"
+      :total="history.total"
+      @update:page="emit('update:page', $event)"
+      @update:page-size="emit('update:page-size', $event)"
+    />
+  </section>
+</template>

package/template/apps/web/src/pages/system/components/SchedulerRunTable.webtest.ts

@@ -0,0 +1,75 @@
+import { mount } from "@vue/test-utils";
+import { describe, expect, test } from "vitest";
+import type { PageResult, SchedulerRunHistoryItem } from "@windy/shared";
+import SchedulerRunTable from "./SchedulerRunTable.vue";
+
+describe("SchedulerRunTable", () => {
+  test("表格显示任务名称并通过快速 Tooltip 显示稳定 key", () => {
+    const wrapper = mount(SchedulerRunTable, {
+      props: { history: history() },
+      global: {
+        stubs: {
+          Tooltip: { template: "<div><slot /></div>" },
+          TooltipTrigger: { template: "<div><slot /></div>" },
+          TooltipContent: {
+            template: '<div data-testid="tooltip-content"><slot /></div>',
+          },
+        },
+      },
+    });
+
+    expect(wrapper.get("button.cursor-help").text()).toBe("调度器健康快照");
+    expect(
+      wrapper.get("button.cursor-help").attributes("title"),
+    ).toBeUndefined();
+    expect(wrapper.get('[data-testid="tooltip-content"]').text()).toBe(
+      "Key：system.scheduler.health-snapshot",
+    );
+    expect(wrapper.text()).toContain("序号");
+    expect(wrapper.text()).toContain("1");
+    expect(wrapper.text()).toContain("手动");
+    expect(wrapper.text()).toContain("成功");
+  });
+
+  test("沿用统一分页并向外传递页码和任意有效页大小", async () => {
+    const wrapper = mount(SchedulerRunTable, {
+      props: { history: history() },
+    });
+
+    expect(
+      wrapper.get('[data-testid="previous-page"]').attributes(),
+    ).toHaveProperty("disabled");
+    expect(
+      wrapper.get('[data-testid="next-page"]').attributes(),
+    ).not.toHaveProperty("disabled");
+
+    await wrapper.get('[data-testid="next-page"]').trigger("click");
+    await wrapper.get('[data-testid="page-size-input"]').setValue("37");
+    await wrapper.get('[data-testid="page-size-input"]').trigger("change");
+
+    expect(wrapper.emitted("update:page")?.[0]).toEqual([2]);
+    expect(wrapper.emitted("update:page-size")?.[0]).toEqual([37]);
+  });
+});
+
+function history(): PageResult<SchedulerRunHistoryItem> {
+  return {
+    items: [
+      {
+        id: "run_1",
+        taskKey: "system.scheduler.health-snapshot",
+        taskLabel: "调度器健康快照",
+        trigger: "manual",
+        status: "succeeded",
+        attempt: 1,
+        requestedBy: "user_dev_admin",
+        scheduledFor: "2026-07-10T00:00:00.000Z",
+        startedAt: "2026-07-10T00:00:00.000Z",
+        finishedAt: "2026-07-10T00:00:01.000Z",
+      },
+    ],
+    total: 25,
+    page: 1,
+    pageSize: 10,
+  };
+}