create-windy 0.8.2 → 0.9.1

package/template/apps/web/src/pages/system/components/agent-workbench/replay-presenter.ts

@@ -0,0 +1,94 @@
+import type {
+  AgentWorkbenchEventV1,
+  AgentWorkbenchRecordingV1,
+} from "@southwind-ai/shared";
+export interface ReplayEntry {
+  readonly event: AgentWorkbenchEventV1;
+  readonly ledger: string;
+  readonly sessionId?: string;
+}
+/** Ledger-local sequence is retained. Expanded children do not imply a global clock. */
+export function replayEntries(
+  recording?: AgentWorkbenchRecordingV1,
+): readonly ReplayEntry[] {
+  if (!recording) return [];
+  const result: ReplayEntry[] = [];
+  const runs = new Set<string>();
+  const workflows = new Set<string>();
+  const segments = recording.segments ?? [
+    {
+      sessionId: recording.sessionId,
+      throughSequence: recording.timeline.at(-1)?.sequence ?? 0,
+      timeline: recording.timeline,
+    },
+  ];
+  for (const segment of segments) {
+    for (const event of segment.timeline) {
+      result.push({
+        event,
+        ledger: `Session ${segment.sessionId}`,
+        sessionId: segment.sessionId,
+      });
+      if (event.runId && !runs.has(event.runId)) {
+        const run = recording.runs.find(
+          (run) =>
+            run.runId === event.runId &&
+            (!run.sessionId || run.sessionId === segment.sessionId),
+        );
+        if (run) {
+          runs.add(run.runId);
+          result.push(
+            ...run.events.map((event) => ({
+              event,
+              ledger: `Run ${run.runId}`,
+              sessionId: run.sessionId ?? segment.sessionId,
+            })),
+          );
+        }
+      }
+      for (const workflow of recording.workflows) {
+        if (
+          workflows.has(workflow.workflowRunId) ||
+          (workflow.sessionId && workflow.sessionId !== segment.sessionId)
+        )
+          continue;
+        if (
+          workflow.workflowRunId !== event.workflowRunId &&
+          (!event.runId || workflow.parentRunId !== event.runId) &&
+          !workflow.nodes.some(
+            (node) => node.agentRunId && node.agentRunId === event.runId,
+          )
+        )
+          continue;
+        workflows.add(workflow.workflowRunId);
+        result.push(
+          ...workflow.events.map((event) => ({
+            event,
+            ledger: `Workflow ${workflow.workflowRunId}`,
+            sessionId: workflow.sessionId ?? segment.sessionId,
+          })),
+        );
+      }
+    }
+  }
+  // Unlinked facts remain explicitly separate; they are never assigned invented Turn IDs.
+  for (const run of recording.runs)
+    if (!runs.has(run.runId))
+      result.push(
+        ...run.events.map((event) => ({
+          event,
+          ledger: `独立 Run ${run.runId}（Session 关联缺失）`,
+          ...(run.sessionId ? { sessionId: run.sessionId } : {}),
+        })),
+      );
+  for (const workflow of recording.workflows)
+    if (!workflows.has(workflow.workflowRunId))
+      result.push(
+        ...workflow.events.map((event) => ({
+          event,
+          ledger: `独立 Workflow ${workflow.workflowRunId}（Session 关联缺失）`,
+          ...(workflow.sessionId ? { sessionId: workflow.sessionId } : {}),
+        })),
+      );
+  return result;
+}

package/template/apps/web/src/pages/system/components/agent-workflow/WorkflowPresetCatalog.vue

@@ -0,0 +1,82 @@
+<script setup lang="ts">
+import { RouterLink } from "vue-router";
+import type { AgentWorkflowPresetSummary } from "@/services/agent-workflow-api";
+import { Badge } from "@/components/ui/badge";
+import { Button } from "@/components/ui/button";
+
+defineProps<{
+  presets: readonly AgentWorkflowPresetSummary[];
+  loading: boolean;
+  error: string;
+}>();
+defineEmits<{ refresh: [] }>();
+</script>
+
+<template>
+  <section
+    aria-labelledby="workflow-preset-title"
+    class="space-y-3"
+    :aria-busy="loading"
+  >
+    <div class="space-y-1">
+      <h2 id="workflow-preset-title" class="text-base font-semibold">
+        业务预设
+      </h2>
+      <p class="text-sm text-muted-foreground">
+        查看已安装模块注册的固定工作流；进入业务页面后按当前材料和权限启动。
+      </p>
+    </div>
+    <p v-if="loading" role="status" class="text-sm text-muted-foreground">
+      正在读取预设…
+    </p>
+    <div
+      v-else-if="error"
+      role="alert"
+      class="rounded-lg border p-4 text-sm text-destructive"
+    >
+      <p>{{ error }}</p>
+      <Button class="mt-2" variant="outline" size="sm" @click="$emit('refresh')"
+        >重试</Button
+      >
+    </div>
+    <p
+      v-else-if="!presets.length"
+      class="rounded-lg border p-4 text-sm text-muted-foreground"
+    >
+      当前没有可访问的业务预设。
+    </p>
+    <ul v-else class="grid gap-3 xl:grid-cols-2">
+      <li
+        v-for="preset in presets"
+        :key="preset.key"
+        class="space-y-3 rounded-lg border bg-card p-4"
+      >
+        <div class="flex flex-wrap items-center justify-between gap-2">
+          <h3 class="font-medium">{{ preset.label }}</h3>
+          <Badge
+            :variant="
+              preset.availability === 'available' ? 'secondary' : 'outline'
+            "
+            >{{
+              preset.availability === "available"
+                ? `v${preset.version}`
+                : "条件未就绪"
+            }}</Badge
+          >
+        </div>
+        <p class="text-sm text-muted-foreground">{{ preset.description }}</p>
+        <p class="text-xs leading-5 text-muted-foreground">
+          {{ preset.nodes.map((node) => node.label).join(" → ") }}
+        </p>
+        <p v-if="preset.blockedReason" class="rounded-md bg-muted p-3 text-xs">
+          {{ preset.blockedReason }}（{{ preset.safeCode }}）
+        </p>
+        <Button v-if="preset.entry" as-child variant="outline" size="sm"
+          ><RouterLink :to="preset.entry.path">{{
+            preset.entry.label
+          }}</RouterLink></Button
+        >
+      </li>
+    </ul>
+  </section>
+</template>

package/template/apps/web/src/pages/system/components/agent-workflow/WorkflowPresetCatalog.webtest.ts

@@ -0,0 +1,57 @@
+import { mount } from "@vue/test-utils";
+import { describe, expect, test } from "vitest";
+import type { AgentWorkflowPresetSummary } from "@/services/agent-workflow-api";
+import WorkflowPresetCatalog from "./WorkflowPresetCatalog.vue";
+
+const preset: AgentWorkflowPresetSummary = {
+  key: "example.work-order",
+  moduleKey: "example",
+  label: "工单办理",
+  description: "办理授权工单",
+  workflowKey: "example.work-order",
+  version: "1.0.0",
+  budget: {
+    maxDurationSeconds: 60,
+    maxModelAttempts: 1,
+    maxToolCalls: 1,
+    maxSubagents: 0,
+    maxParallelism: 1,
+    maxInputTokens: 100,
+    maxOutputTokens: 100,
+    maxCostMicros: 0,
+  },
+  nodes: [{ id: "final", type: "final", label: "确认完成" }],
+  availability: "unavailable",
+  safeCode: "BUSINESS_BINDING_REQUIRED",
+  blockedReason: "尚未登记业务绑定",
+  entry: { path: "/work-orders", label: "进入工单" },
+};
+
+describe("Workflow 预设目录", () => {
+  test("按实际注册投影展示条件与业务入口，不提供发布或启动按钮", () => {
+    const wrapper = mount(WorkflowPresetCatalog, {
+      props: { presets: [preset], loading: false, error: "" },
+      global: {
+        stubs: {
+          RouterLink: { props: ["to"], template: '<a :href="to"><slot /></a>' },
+        },
+      },
+    });
+    expect(wrapper.text()).toContain("工单办理");
+    expect(wrapper.text()).toContain("尚未登记业务绑定");
+    expect(wrapper.get("a").attributes("href")).toBe("/work-orders");
+    expect(wrapper.text()).not.toContain("发布预设");
+    expect(wrapper.text()).not.toContain("立即启动");
+  });
+
+  test("读取失败允许重试，空目录说明当前授权边界", async () => {
+    const wrapper = mount(WorkflowPresetCatalog, {
+      props: { presets: [], loading: false, error: "目录暂不可用" },
+    });
+    expect(wrapper.get('[role="alert"]').text()).toContain("目录暂不可用");
+    await wrapper.get("button").trigger("click");
+    expect(wrapper.emitted("refresh")).toHaveLength(1);
+    await wrapper.setProps({ error: "" });
+    expect(wrapper.text()).toContain("当前没有可访问的业务预设");
+  });
+});

package/template/apps/web/src/pages/system/composables/useAgentSkillsGovernance.ts

@@ -0,0 +1,105 @@
+import { computed, onBeforeUnmount, onMounted, shallowRef } from "vue";
+import {
+  governAgentSkill,
+  listGovernedAgentSkills,
+  type AgentSkillGovernanceItem,
+} from "@/services/agent-skills-api";
+export function useAgentSkillsGovernance() {
+  const items = shallowRef<readonly AgentSkillGovernanceItem[]>([]),
+    loading = shallowRef(false),
+    error = shallowRef(""),
+    query = shallowRef("");
+  const selected = shallowRef<AgentSkillGovernanceItem>(),
+    action = shallowRef<"disable" | "rollback">(),
+    targetVersion = shallowRef<number>();
+  const actionLoading = shallowRef(false),
+    actionError = shallowRef("");
+  let controller: AbortController | undefined,
+    revision = 0,
+    mutationKey = "";
+  const filtered = computed(() => {
+    const needle = query.value.trim().toLocaleLowerCase("zh-CN");
+    return items.value.filter(
+      ({ skill }) =>
+        !needle ||
+        [skill.key, skill.name, skill.description]
+          .join(" ")
+          .toLocaleLowerCase("zh-CN")
+          .includes(needle),
+    );
+  });
+  async function reload() {
+    const current = ++revision;
+    controller?.abort();
+    controller = new AbortController();
+    loading.value = true;
+    error.value = "";
+    try {
+      const result = await listGovernedAgentSkills(controller.signal);
+      if (current === revision) items.value = result;
+    } catch (cause) {
+      if (current === revision && !controller.signal.aborted)
+        error.value =
+          cause instanceof Error ? cause.message : "技能目录读取失败";
+    } finally {
+      if (current === revision) loading.value = false;
+    }
+  }
+  function requestAction(value: "disable" | "rollback", version?: number) {
+    action.value = value;
+    targetVersion.value = version;
+    actionError.value = "";
+    mutationKey = crypto.randomUUID();
+  }
+  function closeAction() {
+    if (actionLoading.value) return;
+    action.value = undefined;
+    actionError.value = "";
+    mutationKey = "";
+  }
+  async function confirmAction() {
+    if (actionLoading.value || !selected.value || !action.value) return;
+    actionLoading.value = true;
+    actionError.value = "";
+    try {
+      await governAgentSkill(
+        selected.value.skill.key,
+        action.value,
+        {
+          expectedVersion: selected.value.skill.version,
+          ...(targetVersion.value ? { version: targetVersion.value } : {}),
+        },
+        mutationKey,
+      );
+      action.value = undefined;
+      selected.value = undefined;
+      await reload();
+    } catch (cause) {
+      actionError.value =
+        cause instanceof Error ? cause.message : "技能变更失败";
+    } finally {
+      actionLoading.value = false;
+    }
+  }
+  onMounted(reload);
+  onBeforeUnmount(() => {
+    revision++;
+    controller?.abort();
+  });
+  return {
+    items,
+    loading,
+    error,
+    query,
+    filtered,
+    selected,
+    action,
+    actionError,
+    actionLoading,
+    targetVersion,
+    reload,
+    requestAction,
+    closeAction,
+    confirmAction,
+  };
+}

package/template/apps/web/src/pages/system/composables/useAgentWorkbench.ts

@@ -0,0 +1,298 @@
+import { computed, onBeforeUnmount, onMounted, shallowRef, watch } from "vue";
+import type {
+  AgentAdminOperationCatalogItem,
+  AgentWorkbenchEventV1,
+  AgentWorkbenchRecordingSummaryV1,
+  AgentWorkbenchRecordingV1,
+  JsonValue,
+} from "@southwind-ai/shared";
+import { useAuthSession } from "@/composables/useAuthSession";
+import { useAccessSnapshot } from "@/composables/useAccessSnapshot";
+import {
+  cancelTestRun,
+  createTestRun,
+  createTestSession,
+  getTestRunResult,
+  getWorkbenchRecording,
+  listAdminOperations,
+  listWorkbenchRecordings,
+  streamTestRun,
+} from "@/services/agent-admin-api";
+export function useAgentWorkbench() {
+  const access = useAccessSnapshot();
+  const auth = useAuthSession();
+  const sessions = shallowRef<readonly AgentWorkbenchRecordingSummaryV1[]>([]);
+  const operations = shallowRef<readonly AgentAdminOperationCatalogItem[]>([]);
+  const selected = shallowRef<AgentWorkbenchRecordingSummaryV1>();
+  const recording = shallowRef<AgentWorkbenchRecordingV1>();
+  const liveEvents = shallowRef<readonly AgentWorkbenchEventV1[]>([]);
+  const liveRun = shallowRef<{
+    runId: string;
+    operationKey: string;
+    sessionId: string;
+    status: string;
+  }>();
+  const output = shallowRef<JsonValue>();
+  const error = shallowRef("");
+  const loading = shallowRef(false);
+  const starting = shallowRef(false);
+  const cancelling = shallowRef(false);
+  let listController: AbortController | undefined;
+  let detailController: AbortController | undefined;
+  let runController: AbortController | undefined;
+  let cancelController: AbortController | undefined;
+  const testSessions = new Set<string>();
+  const canManage = computed(() =>
+    Boolean(
+      access.snapshot.value?.actor.permissionKeys.includes(
+        "system.agent-debug.manage",
+      ),
+    ),
+  );
+  const running = computed(() =>
+    Boolean(
+      liveRun.value &&
+      !["completed", "failed", "cancelled"].includes(liveRun.value.status),
+    ),
+  );
+  function clear() {
+    listController?.abort();
+    detailController?.abort();
+    runController?.abort();
+    cancelController?.abort();
+    listController = undefined;
+    detailController = undefined;
+    runController = undefined;
+    cancelController = undefined;
+    testSessions.clear();
+    loading.value = false;
+    starting.value = false;
+    cancelling.value = false;
+    sessions.value = [];
+    operations.value = [];
+    selected.value = undefined;
+    recording.value = undefined;
+    liveEvents.value = [];
+    liveRun.value = undefined;
+    output.value = undefined;
+  }
+  watch([access.fingerprint, () => auth.actor.value?.id], () => {
+    clear();
+    error.value = "当前身份或授权发生变化，旧记录已隐藏，请手动刷新。";
+  });
+  onMounted(refresh);
+  onBeforeUnmount(() => {
+    listController?.abort();
+    detailController?.abort();
+    runController?.abort();
+    cancelController?.abort();
+  });
+  async function refresh() {
+    listController?.abort();
+    const controller = new AbortController();
+    listController = controller;
+    error.value = "";
+    loading.value = true;
+    const results = await Promise.allSettled([
+      listWorkbenchRecordings("harness", controller.signal),
+      listWorkbenchRecordings("business", controller.signal),
+      listAdminOperations(controller.signal),
+    ]);
+    if (controller.signal.aborted || listController !== controller) return;
+    const [harness, business, operation] = results;
+    sessions.value = [
+      ...(harness.status === "fulfilled" ? harness.value.items : []),
+      ...(business.status === "fulfilled" ? business.value.items : []),
+    ];
+    operations.value = operation.status === "fulfilled" ? operation.value : [];
+    const failures = results
+      .filter((result) => result.status === "rejected")
+      .map((result) => message(result.reason));
+    if (failures.length) error.value = failures.join("；");
+    loading.value = false;
+    if (selected.value) await select(selected.value);
+  }
+  async function select(session?: AgentWorkbenchRecordingSummaryV1) {
+    detailController?.abort();
+    const preserveLive = Boolean(
+      session &&
+      session.source === "harness" &&
+      liveRun.value?.sessionId === session.sessionId,
+    );
+    if (!preserveLive) {
+      runController?.abort();
+      cancelController?.abort();
+      runController = undefined;
+      cancelController = undefined;
+      starting.value = false;
+      cancelling.value = false;
+      liveEvents.value = [];
+      liveRun.value = undefined;
+      output.value = undefined;
+    }
+    selected.value = session;
+    recording.value = undefined;
+    error.value = "";
+    if (!session) return;
+    const controller = new AbortController();
+    detailController = controller;
+    loading.value = true;
+    try {
+      const result = await getWorkbenchRecording(
+        session.sessionId,
+        session.source,
+        controller.signal,
+      );
+      if (!controller.signal.aborted && detailController === controller)
+        recording.value = result;
+    } catch (failure) {
+      if (!controller.signal.aborted) error.value = message(failure);
+    } finally {
+      if (detailController === controller) loading.value = false;
+    }
+  }
+  async function start(
+    operationKey: string,
+    input: JsonValue,
+  ): Promise<boolean> {
+    if (!canManage.value || starting.value || running.value) return false;
+    starting.value = true;
+    error.value = "";
+    runController?.abort();
+    const controller = new AbortController();
+    runController = controller;
+    try {
+      let session = selected.value;
+      if (
+        !session ||
+        session.source !== "harness" ||
+        !testSessions.has(session.sessionId)
+      ) {
+        const created = await createTestSession(controller.signal);
+        if (controller.signal.aborted || runController !== controller)
+          return false;
+        testSessions.add(created.sessionId);
+        session = {
+          source: "harness",
+          sessionId: created.sessionId,
+          title: "调试测试会话",
+          updatedAt: new Date().toISOString(),
+        };
+        selected.value = session;
+        recording.value = undefined;
+        sessions.value = [session, ...sessions.value];
+      }
+      const created = await createTestRun(
+        operationKey,
+        input,
+        session.sessionId,
+        controller.signal,
+      );
+      if (controller.signal.aborted || runController !== controller)
+        return false;
+      liveEvents.value = [];
+      output.value = undefined;
+      liveRun.value = {
+        ...created,
+        operationKey,
+        sessionId: session.sessionId,
+      };
+      void follow(liveRun.value, controller);
+      return true;
+    } catch (failure) {
+      if (!controller.signal.aborted) error.value = message(failure);
+      return false;
+    } finally {
+      if (runController === controller) starting.value = false;
+    }
+  }
+  async function follow(
+    run: NonNullable<typeof liveRun.value>,
+    controller: AbortController,
+  ) {
+    try {
+      await streamTestRun(
+        run.runId,
+        run.operationKey,
+        run.sessionId,
+        (event) => {
+          if (controller.signal.aborted || runController !== controller) return;
+          if (
+            !liveEvents.value.some(
+              (current) => current.sequence === event.sequence,
+            )
+          )
+            liveEvents.value = [...liveEvents.value, event];
+          const status = event.type.startsWith("run.")
+            ? event.type.slice(4)
+            : undefined;
+          if (status && ["completed", "failed", "cancelled"].includes(status))
+            liveRun.value = { ...run, status };
+        },
+        controller.signal,
+      );
+      if (controller.signal.aborted || runController !== controller) return;
+      const result = await getTestRunResult(
+        run.runId,
+        run.operationKey,
+        run.sessionId,
+        controller.signal,
+      );
+      if (controller.signal.aborted || runController !== controller) return;
+      output.value = result.output;
+      liveRun.value = { ...run, status: result.status };
+      const history = await getWorkbenchRecording(
+        run.sessionId,
+        "harness",
+        controller.signal,
+      );
+      if (!controller.signal.aborted) recording.value = history;
+    } catch (failure) {
+      if (!controller.signal.aborted)
+        error.value = `${message(failure)}。运行未自动重试，请手动刷新会话。`;
+    }
+  }
+  async function cancel() {
+    const run = liveRun.value;
+    if (!run || cancelling.value) return;
+    cancelling.value = true;
+    cancelController?.abort();
+    const controller = new AbortController();
+    cancelController = controller;
+    try {
+      await cancelTestRun(
+        run.runId,
+        run.operationKey,
+        run.sessionId,
+        controller.signal,
+      );
+    } catch (failure) {
+      if (!controller.signal.aborted && cancelController === controller)
+        error.value = message(failure);
+    } finally {
+      if (cancelController === controller) cancelling.value = false;
+    }
+  }
+  return {
+    sessions,
+    operations,
+    selected,
+    recording,
+    liveEvents,
+    liveRun,
+    output,
+    error,
+    loading,
+    starting,
+    cancelling,
+    running,
+    canManage,
+    refresh,
+    select,
+    start,
+    cancel,
+  };
+}
+function message(error: unknown) {
+  return error instanceof Error ? error.message : "会话服务不可用";
+}