create-windy 0.8.2 → 0.9.1

package/template/apps/web/Dockerfile

@@ -1,15 +1,20 @@
 # syntax=docker/dockerfile:1
 
+FROM node:24.7.0-alpine AS node
+
 FROM oven/bun:1.3.14-alpine AS deps
+COPY --from=node /usr/local/bin/node /usr/local/bin/node
 WORKDIR /app
 
 COPY package.json bun.lock ./
 COPY windy.modules.json windy.modules.json
 # windy-copy:deps begin
+COPY apps/agent-server/package.json apps/agent-server/package.json
 COPY apps/license/package.json apps/license/package.json
 COPY apps/server/package.json apps/server/package.json
 COPY apps/signing-service/package.json apps/signing-service/package.json
 COPY apps/web/package.json apps/web/package.json
+COPY apps/windy-gateway/package.json apps/windy-gateway/package.json
 COPY packages/ai-client/package.json packages/ai-client/package.json
 COPY packages/config/package.json packages/config/package.json
 COPY packages/create-windy/package.json packages/create-windy/package.json
@@ -19,6 +24,7 @@ COPY packages/delivery/package.json packages/delivery/package.json
 COPY packages/example-work-order/package.json packages/example-work-order/package.json
 COPY packages/jobs/package.json packages/jobs/package.json
 COPY packages/license-sdk/package.json packages/license-sdk/package.json
+COPY packages/model-gateway/package.json packages/model-gateway/package.json
 COPY packages/modules/package.json packages/modules/package.json
 COPY packages/server-sdk/package.json packages/server-sdk/package.json
 COPY packages/shared/package.json packages/shared/package.json
@@ -39,12 +45,14 @@ COPY packages/storage packages/storage
 # windy-copy:build end
 # Bun 1.3.14 on Linux resolves Vite's relative imports from the .bin symlink
 # instead of its real package entry. Execute the immutable hoisted entry directly.
-RUN cd apps/web && bun ../../node_modules/vite/bin/vite.js build
+RUN cd apps/web && node ../../node_modules/vite/bin/vite.js build
 
 FROM deps AS runner
 COPY apps/web/package.json apps/web/package.json
 COPY apps/web/server.ts apps/web/server.ts
 COPY apps/web/runtime-server.ts apps/web/runtime-server.ts
+COPY apps/web/dsh-workbench-proxy.ts apps/web/dsh-workbench-proxy.ts
+COPY apps/web/dsh-workbench-location.ts apps/web/dsh-workbench-location.ts
 COPY packages/shared packages/shared
 COPY --from=build /app/apps/web/dist apps/web/dist
 ENV NODE_ENV=production

package/template/apps/web/dev/start.ts

@@ -1,3 +1,5 @@
+import { dirname, join } from "node:path";
+import { createRequire } from "node:module";
 import { projectFingerprint } from "./dev-identity";
 import { selectDevPort } from "./dev-port";
 
@@ -14,17 +16,26 @@ if (selection.kind === "existing") {
 }
 
 console.info(`启动 Windy Web：${url}`);
-const child = Bun.spawn(["bunx", "--bun", "vite"], {
-  cwd: process.cwd(),
-  env: {
-    ...process.env,
-    WINDY_DEV_PORT: String(selection.port),
-    WINDY_DEV_FINGERPRINT: fingerprint,
+const child = Bun.spawn(
+  [
+    "node",
+    join(
+      dirname(createRequire(import.meta.url).resolve("vite/package.json")),
+      "bin/vite.js",
+    ),
+  ],
+  {
+    cwd: process.cwd(),
+    env: {
+      ...process.env,
+      WINDY_DEV_PORT: String(selection.port),
+      WINDY_DEV_FINGERPRINT: fingerprint,
+    },
+    stdin: "inherit",
+    stdout: "inherit",
+    stderr: "inherit",
   },
-  stdin: "inherit",
-  stdout: "inherit",
-  stderr: "inherit",
-});
+);
 process.exit(await child.exited);
 
 function parseConfiguredPort(value: string | undefined): number | undefined {

package/template/apps/web/dsh-workbench-location.ts

@@ -0,0 +1,21 @@
+/** The pairing and one-use handoff pages remain owned by the product SPA. */
+export function isDshWorkbenchPath(path: string): boolean {
+  const url = new URL(path, "http://web.internal");
+  if (url.pathname === "/agent" || url.pathname === "/agent/")
+    return !url.searchParams.has("handoff");
+  return (
+    url.pathname.startsWith("/agent/") &&
+    url.pathname !== "/agent/connect" &&
+    !url.pathname.startsWith("/agent/connect/")
+  );
+}
+
+export function dshWorkbenchProxyPath(path: string): string {
+  return path.replace(/^\/agent(?:\/|(?=\?|$))/, "/api/agent/native/");
+}
+
+export function dshWorkbenchLoginPath(path: string): string | undefined {
+  const url = new URL(path, "http://web.internal");
+  if (url.pathname !== "/agent" && url.pathname !== "/agent/") return;
+  return `/login?returnTo=${encodeURIComponent(`${url.pathname}${url.search}`)}`;
+}

package/template/apps/web/dsh-workbench-proxy.test.ts

@@ -0,0 +1,121 @@
+import { expect, test } from "bun:test";
+import {
+  dshWorkbenchProxyPath,
+  isDshWorkbenchPath,
+} from "./dsh-workbench-location";
+import { createDshWebProxy } from "./dsh-workbench-proxy";
+
+test("native mount accepts the bare entry and preserves pairing and handoff in the SPA", () => {
+  for (const path of [
+    "/agent",
+    "/agent/",
+    "/agent?session=abc",
+    "/agent/assets/a.js",
+  ])
+    expect(isDshWorkbenchPath(path)).toBe(true);
+  for (const path of [
+    "/agent/connect",
+    "/agent/connect?pairing=abc",
+    "/agent/connect/",
+    "/agent?handoff=one-use",
+    "/agent/?handoff=one-use",
+    "/agents",
+  ])
+    expect(isDshWorkbenchPath(path)).toBe(false);
+  expect(dshWorkbenchProxyPath("/agent")).toBe("/api/agent/native/");
+  expect(dshWorkbenchProxyPath("/agent?session=abc")).toBe(
+    "/api/agent/native/?session=abc",
+  );
+  expect(dshWorkbenchProxyPath("/agent/assets/a.js")).toBe(
+    "/api/agent/native/assets/a.js",
+  );
+});
+
+test("production entry serves the native document directly and retains login redirects", async () => {
+  const requests: Request[] = [];
+  const upstream = Bun.serve({
+    hostname: "127.0.0.1",
+    port: 0,
+    fetch(request) {
+      requests.push(new Request(request.url, { headers: request.headers }));
+      return request.headers.has("cookie")
+        ? new Response("<html>DSH</html>", {
+            headers: { "content-type": "text/html" },
+          })
+        : Response.json({ error: "UNAUTHENTICATED" }, { status: 401 });
+    },
+  });
+  try {
+    const proxy = createDshWebProxy(upstream.url.origin);
+    const server = {} as Parameters<typeof proxy.fetch>[1];
+    const response = await proxy.fetch(
+      new Request("https://windy.test/agent?session=abc", {
+        headers: { cookie: "windy.sid=fixture", "x-windy-actor-id": "forged" },
+      }),
+      server,
+    );
+    expect(response?.status).toBe(200);
+    expect(response?.headers.get("location")).toBeNull();
+    expect(await response?.text()).toBe("<html>DSH</html>");
+    expect(new URL(requests[0]!.url).pathname).toBe("/api/agent/native/");
+    expect(new URL(requests[0]!.url).search).toBe("?session=abc");
+    expect(requests[0]!.headers.get("x-windy-actor-id")).toBeNull();
+    const anonymous = await proxy.fetch(
+      new Request("https://windy.test/agent"),
+      server,
+    );
+    expect(anonymous?.status).toBe(302);
+    expect(anonymous?.headers.get("location")).toBe("/login?returnTo=%2Fagent");
+    const api = await proxy.fetch(
+      new Request("https://windy.test/agent/api/status"),
+      server,
+    );
+    expect(api?.status).toBe(401);
+  } finally {
+    await upstream.stop(true);
+  }
+});
+
+test("production skill generation survives short default idle timeout and strips private browser headers", async () => {
+  let received: Request | undefined;
+  const upstream = Bun.serve({
+    hostname: "127.0.0.1",
+    port: 0,
+    idleTimeout: 10,
+    async fetch(request) {
+      received = request;
+      const body = await request.json();
+      expect(body).toEqual({ action: "draft", workflow: "整理材料" });
+      await new Promise((resolve) => setTimeout(resolve, 3100));
+      return Response.json({ draft: { name: "synthetic" } });
+    },
+  });
+  const proxy = createDshWebProxy(upstream.url.origin);
+  const web = Bun.serve({
+    hostname: "127.0.0.1",
+    port: 0,
+    idleTimeout: 1,
+    fetch: proxy.fetch,
+    websocket: proxy.websocket,
+  });
+  try {
+    const response = await fetch(new URL("/agent/windy/skills", web.url), {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        "x-windy-skill-draft-complete": "1",
+      },
+      body: JSON.stringify({ action: "draft", workflow: "整理材料" }),
+      signal: AbortSignal.timeout(10_000),
+    });
+    expect(response.status).toBe(200);
+    expect(await response.json()).toEqual({ draft: { name: "synthetic" } });
+    expect(new URL(received!.url).pathname).toBe(
+      "/api/agent/native/windy/skills",
+    );
+    expect(received!.headers.has("x-windy-skill-draft-complete")).toBe(false);
+  } finally {
+    await web.stop(true);
+    await upstream.stop(true);
+  }
+});

package/template/apps/web/dsh-workbench-proxy.ts

@@ -0,0 +1,194 @@
+import WebSocket from "ws";
+import type { Server, ServerWebSocket } from "bun";
+import {
+  dshWorkbenchLoginPath,
+  dshWorkbenchProxyPath,
+} from "./dsh-workbench-location";
+export { isDshWorkbenchPath } from "./dsh-workbench-location";
+
+export interface DshWebSocketState {
+  readonly upstream: WebSocket;
+  readonly pending: (string | Uint8Array)[];
+  client?: ServerWebSocket<DshWebSocketState>;
+  bufferedBytes: number;
+  closed: boolean;
+}
+
+export function createDshWebProxy(apiUpstream?: string) {
+  const target = (request: Request) => {
+    if (!apiUpstream) throw new Error("API_UPSTREAM_NOT_CONFIGURED");
+    const url = new URL(request.url);
+    return new URL(
+      dshWorkbenchProxyPath(`${url.pathname}${url.search}`),
+      apiUpstream,
+    );
+  };
+  return {
+    async fetch(
+      request: Request,
+      server: Server<DshWebSocketState>,
+    ): Promise<Response | undefined> {
+      try {
+        const url = target(request);
+        const headers = new Headers(request.headers);
+        for (const name of [
+          "host",
+          "connection",
+          "content-length",
+          "upgrade",
+          "sec-websocket-key",
+          "sec-websocket-version",
+          "sec-websocket-extensions",
+        ])
+          headers.delete(name);
+        // Bun builds the API request URL from Host. Keep the browser authority
+        // for HTTP LAN deployments without a fixed public base URL, while the
+        // network destination remains the configured API upstream.
+        headers.set("host", new URL(request.url).host);
+        headers.delete("forwarded");
+        headers.delete("x-forwarded-host");
+        headers.delete("x-forwarded-proto");
+        const privateHeaders: string[] = [];
+        headers.forEach((_value, name) => {
+          if (name.startsWith("x-windy-")) privateHeaders.push(name);
+        });
+        for (const name of privateHeaders) headers.delete(name);
+        if (request.headers.get("upgrade")?.toLowerCase() !== "websocket") {
+          const skillRequest =
+            request.method === "POST" &&
+            new URL(request.url).pathname === "/agent/windy/skills";
+          if (skillRequest) server.timeout(request, 120);
+          const response = await fetch(url, {
+            method: request.method,
+            headers,
+            body: ["GET", "HEAD"].includes(request.method)
+              ? undefined
+              : request.body,
+            redirect: "manual",
+            signal: skillRequest
+              ? AbortSignal.any([request.signal, AbortSignal.timeout(115_000)])
+              : request.signal,
+          });
+          const login = dshWorkbenchLoginPath(request.url);
+          if (response.status === 401 && login) {
+            await response.body?.cancel();
+            return new Response(null, {
+              status: 302,
+              headers: { location: login, "cache-control": "no-store" },
+            });
+          }
+          return response;
+        }
+        if (new URL(request.url).pathname !== "/agent/api/remote.mux")
+          return unavailable(404);
+        url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+        const upstream = new WebSocket(url, { headers: headerRecord(headers) });
+        upstream.binaryType = "arraybuffer";
+        const state: DshWebSocketState = {
+          upstream,
+          pending: [],
+          bufferedBytes: 0,
+          closed: false,
+        };
+        upstream.addEventListener("message", (event) => {
+          const frame =
+            typeof event.data === "string"
+              ? event.data
+              : new Uint8Array(event.data as ArrayBuffer);
+          if (state.client) {
+            if (state.client.send(frame) === 0) close(state, 1013);
+          } else {
+            state.bufferedBytes +=
+              typeof frame === "string"
+                ? Buffer.byteLength(frame)
+                : frame.byteLength;
+            if (state.bufferedBytes > 2_097_152 || state.pending.length >= 128)
+              return close(state, 1013);
+            state.pending.push(frame);
+          }
+        });
+        upstream.addEventListener("close", (event) => {
+          const code = event.code === 1008 ? 1008 : 1011;
+          close(state, code);
+        });
+        const opened = await new Promise<boolean>((resolve) => {
+          const timeout = setTimeout(() => {
+            upstream.close();
+            resolve(false);
+          }, 10_000);
+          const settle = (ok: boolean) => {
+            clearTimeout(timeout);
+            resolve(ok);
+          };
+          upstream.addEventListener("open", () => settle(true), { once: true });
+          upstream.addEventListener("error", () => settle(false), {
+            once: true,
+          });
+          upstream.addEventListener("close", () => settle(false), {
+            once: true,
+          });
+        });
+        if (!opened) {
+          close(state);
+          return unavailable(503);
+        }
+        if (server.upgrade(request, { data: state })) return;
+        close(state);
+        return unavailable(400);
+      } catch {
+        return unavailable(503);
+      }
+    },
+    websocket: {
+      open(client: ServerWebSocket<DshWebSocketState>) {
+        const state = client.data;
+        state.client = client;
+        if (state.upstream.readyState !== WebSocket.OPEN)
+          return close(state, 1011);
+        for (const frame of state.pending)
+          if (client.send(frame) === 0) return close(state, 1013);
+        state.pending.length = 0;
+        state.bufferedBytes = 0;
+      },
+      message(
+        client: ServerWebSocket<DshWebSocketState>,
+        message: string | Buffer,
+      ) {
+        const { upstream } = client.data;
+        if (
+          upstream.readyState !== WebSocket.OPEN ||
+          upstream.bufferedAmount > 8_388_608
+        )
+          return close(client.data, 1013);
+        upstream.send(message);
+      },
+      close(client: ServerWebSocket<DshWebSocketState>) {
+        client.data.closed = true;
+        client.data.pending.length = 0;
+        client.data.upstream.close();
+      },
+    },
+  };
+}
+
+function close(state: DshWebSocketState, code = 1000) {
+  if (state.closed) return;
+  state.closed = true;
+  state.pending.length = 0;
+  state.upstream.close();
+  state.client?.close(code, "Agent disconnected");
+}
+function unavailable(status: number) {
+  return Response.json(
+    { error: "AGENT_UNAVAILABLE" },
+    { status, headers: { "cache-control": "no-store" } },
+  );
+}
+
+function headerRecord(headers: Headers): Record<string, string> {
+  const record: Record<string, string> = {};
+  headers.forEach((value, name) => {
+    record[name] = value;
+  });
+  return record;
+}

package/template/apps/web/package.json

@@ -32,11 +32,13 @@
     "vee-validate": "^4.15.1",
     "vue": "^3.5.39",
     "vue-router": "^5.1.0",
-    "vue-sonner": "^2.0.9"
+    "vue-sonner": "^2.0.9",
+    "ws": "^8.22.0"
   },
   "devDependencies": {
     "@southwind-ai/modules": "workspace:*",
     "@types/qrcode": "^1.5.6",
+    "@types/ws": "^8.18.2",
     "@vitejs/plugin-vue": "^6.0.7",
     "@vue/test-utils": "^2.4.11",
     "happy-dom": "^20.10.6",

package/template/apps/web/server.ts

@@ -1,14 +1,35 @@
 import { join } from "node:path";
 import { createWebFetchHandler } from "./runtime-server";
 
+// @windy-module system.agent begin
+import {
+  createDshWebProxy,
+  isDshWorkbenchPath,
+  type DshWebSocketState,
+} from "./dsh-workbench-proxy";
+// @windy-module system.agent end
+
 const port = process.env.PORT ? Number(process.env.PORT) : 9_746;
-const server = Bun.serve({
-  port,
-  fetch: createWebFetchHandler({
-    distDir: join(process.cwd(), "dist"),
-    apiUpstream: process.env.API_UPSTREAM?.trim(),
-  }),
+const serve = createWebFetchHandler({
+  distDir: join(process.cwd(), "dist"),
+  apiUpstream: process.env.API_UPSTREAM?.trim(),
 });
+let startServer: () => { readonly port: number } = () =>
+  Bun.serve({ port, fetch: serve });
+// @windy-module system.agent begin
+const native = createDshWebProxy(process.env.API_UPSTREAM?.trim());
+startServer = () =>
+  Bun.serve<DshWebSocketState>({
+    port,
+    fetch(request, server) {
+      return isDshWorkbenchPath(request.url)
+        ? native.fetch(request, server)
+        : serve(request);
+    },
+    websocket: native.websocket,
+  });
+// @windy-module system.agent end
+const server = startServer();
 
 console.info(
   JSON.stringify({

package/template/apps/web/src/composables/useLoginFlow.ts

@@ -25,7 +25,19 @@ export function useLoginFlow() {
       resetLicenseRuntime();
       // @windy-module system.license end
       resetSessionContext();
-      await router.replace(safeReturnTo(route.query.returnTo));
+      const returnTo = safeReturnTo(route.query.returnTo);
+      // @windy-module system.agent begin
+      if (
+        new URL(returnTo, window.location.origin).pathname.replace(
+          /\/$/,
+          "",
+        ) === "/agent"
+      ) {
+        window.location.assign(returnTo);
+        return;
+      }
+      // @windy-module system.agent end
+      await router.replace(returnTo);
     } catch {
       submitError.value = auth.error.value || "登录失败，请稍后重试";
     }

package/template/apps/web/src/pages/errors/PlatformErrorPage.vue

@@ -90,6 +90,12 @@ const primaryTarget = computed(() =>
               <dt>原请求地址</dt>
               <dd class="break-all font-mono text-foreground">{{ from }}</dd>
             </div>
+            <div v-if="diagnosticId" class="flex flex-wrap gap-2">
+              <dt>诊断编号</dt>
+              <dd class="break-all font-mono text-foreground">
+                {{ diagnosticId }}
+              </dd>
+            </div>
             <div v-if="requestId" class="flex flex-wrap gap-2">
               <dt>Request ID</dt>
               <dd class="break-all font-mono text-foreground">

package/template/apps/web/src/pages/errors/PlatformErrorPage.webtest.ts

@@ -3,12 +3,17 @@ import { describe, expect, test } from "vitest";
 import PlatformErrorPage from "./PlatformErrorPage.vue";
 import type { ErrorPageKind } from "./error-page-extension";
 
-function render(kind: ErrorPageKind, requestId?: string) {
+function render(
+  kind: ErrorPageKind,
+  requestId?: string,
+  diagnosticId?: string,
+) {
   return mount(PlatformErrorPage, {
     props: {
       kind,
       from: "/records/42",
       requestId,
+      diagnosticId,
     },
     global: {
       stubs: {
@@ -41,4 +46,12 @@ describe("平台统一错误页", () => {
     expect(wrapper.text()).toContain("Request ID");
     expect(wrapper.text()).toContain("req-error-page-1");
   });
+
+  test("错误页展示可用于后台查询的完整诊断编号，保留独立 Request ID", () => {
+    const diagnosticId = "diag-019a1234-5678-7000-8000-000000000001";
+    const wrapper = render("maintenance", "req-independent", diagnosticId);
+    expect(wrapper.text()).toContain("诊断编号");
+    expect(wrapper.text()).toContain(diagnosticId);
+    expect(wrapper.text()).toContain("req-independent");
+  });
 });

package/template/apps/web/src/pages/errors/error-page-extension.ts

@@ -10,6 +10,7 @@ export interface ErrorPageProps {
   kind: ErrorPageKind;
   from: string;
   requestId?: string;
+  diagnosticId?: string;
 }
 
 export interface ErrorPageComponents {

package/template/apps/web/src/pages/system/AgentDebugPage.vue

@@ -0,0 +1,14 @@
+<script setup lang="ts">
+import AgentWorkbench from "./components/agent-workbench/AgentWorkbench.vue";
+</script>
+<template>
+  <div class="space-y-5">
+    <header>
+      <h1 class="text-2xl font-semibold">Agent 调试与会话回放</h1>
+      <p class="mt-2 text-sm text-muted-foreground">
+        在同一视图查看业务会话的多轮调用、工具、审批、产物与工作流，或创建真实受治理测试。
+      </p>
+    </header>
+    <AgentWorkbench />
+  </div>
+</template>

package/template/apps/web/src/pages/system/AgentNativePage.vue

@@ -0,0 +1,44 @@
+<script setup lang="ts">
+import { onMounted, shallowRef } from "vue";
+import { Button } from "@/components/ui/button";
+import { apiRequest } from "@/services/http";
+const loading = shallowRef(false);
+const error = shallowRef("");
+async function open() {
+  if (loading.value) return;
+  loading.value = true;
+  error.value = "";
+  try {
+    const state = await apiRequest<{ status: string; reason?: string }>(
+      "/agent/workbench",
+    );
+    if (state.status === "available") window.location.assign("/agent");
+    else
+      error.value =
+        state.reason === "capacity-reserved"
+          ? "当前模型容量已为业务调用预留，请联系管理员配置工作台容量。"
+          : state.reason === "model-unconfigured"
+            ? "尚未配置可用模型。"
+            : "Agent 工作台暂不可用，请稍后手动重试。";
+  } catch (cause) {
+    error.value = cause instanceof Error ? cause.message : "工作台暂不可用";
+  } finally {
+    loading.value = false;
+  }
+}
+onMounted(open);
+</script>
+<template>
+  <section class="max-w-2xl space-y-4">
+    <h1 class="text-2xl font-semibold">Agent 原生工作台</h1>
+    <p class="text-sm text-muted-foreground">
+      在独立工作区中使用会话、文件与技能。当前登录与业务权限持续生效。
+    </p>
+    <p v-if="error" role="alert" class="text-sm text-destructive">
+      {{ error }}
+    </p>
+    <Button :disabled="loading" @click="open">{{
+      loading ? "正在连接…" : "打开工作台"
+    }}</Button>
+  </section>
+</template>

package/template/apps/web/src/pages/system/AgentSessionPage.vue

@@ -1,5 +1,7 @@
 <script setup lang="ts">
 import { computed } from "vue";
+import { RouterLink } from "vue-router";
+import { useAccessSnapshot } from "@/composables/useAccessSnapshot";
 import { RefreshCwIcon } from "@lucide/vue";
 import { Button } from "@/components/ui/button";
 import AgentSessionDetail from "./components/agent-session/AgentSessionDetail.vue";
@@ -7,6 +9,12 @@ import AgentSessionList from "./components/agent-session/AgentSessionList.vue";
 import { useAgentSessions } from "./composables/useAgentSessions";
 
 const sessionState = useAgentSessions();
+const access = useAccessSnapshot();
+const canOpenWorkbench = computed(() =>
+  access.snapshot.value?.actor.permissionKeys.includes(
+    "system.agent-debug.read",
+  ),
+);
 const selectedSession = computed(() =>
   sessionState.sessions.value.find(
     ({ sessionId }) => sessionId === sessionState.selectedSessionId.value,
@@ -30,14 +38,27 @@ const refreshing = computed(
           查看长期 Session、公开事件摘要、模型 Context 来源和受控 Memory 投影。
         </p>
       </div>
-      <Button
-        variant="outline"
-        :disabled="refreshing"
-        @click="sessionState.refresh"
-      >
-        <RefreshCwIcon data-icon="inline-start" />
-        刷新
-      </Button>
+      <div class="flex gap-2">
+        <Button v-if="canOpenWorkbench" variant="outline" as-child
+          ><RouterLink
+            :to="{
+              path: '/admin/system/agent-debug',
+              query: selectedSession
+                ? { sessionId: selectedSession.sessionId }
+                : {},
+            }"
+            >统一会话回放</RouterLink
+          ></Button
+        >
+        <Button
+          variant="outline"
+          :disabled="refreshing"
+          @click="sessionState.refresh"
+        >
+          <RefreshCwIcon data-icon="inline-start" />
+          刷新
+        </Button>
+      </div>
     </header>
 
     <div