create-windy 0.8.3 → 0.9.1

package/template/apps/agent-server/plugins/tool-catalog/presentation.mjs

@@ -0,0 +1,153 @@
+import { createHash } from "node:crypto";
+import { categoryMetadata } from "./categories.mjs";
+const native = {
+  explain_feature: ["查看功能说明", "了解功能用途、操作入口与适用边界。"],
+  save_workflow_skill: [
+    "保存流程技能",
+    "预览并确认，将已完成流程保存为个人技能。",
+  ],
+  discover_business_tools: [
+    "查找业务工具",
+    "按任务查找并启用获准的业务查询或操作工具。",
+  ],
+  list_agents: ["查看协作助手", "查看当前任务可用的协作助手。"],
+  spawn_teammate: ["创建协作助手", "为独立分析任务创建协作助手。"],
+  interrupt_agent: ["停止协作任务", "停止指定的协作分析任务。"],
+  wait_subagents: ["等待协作结果", "等待协作助手完成当前任务。"],
+  delete: ["删除工作区文件", "删除当前工作区中指定的文件。"],
+  exec: ["运行工作区命令", "执行工作区中获准的命令。"],
+  exec_command: ["运行工作区命令", "执行工作区中获准的命令。"],
+  write_stdin: ["继续命令交互", "向正在运行的命令发送输入或读取输出。"],
+  job_output: ["读取后台结果", "查看后台任务的处理结果。"],
+  job_list: ["查看后台任务", "列出当前可见的后台任务。"],
+  job_kill: ["停止后台任务", "停止指定的后台任务。"],
+  get_goal: ["查看任务目标", "查看当前任务的目标与进度。"],
+  create_goal: ["设定任务目标", "记录当前任务的目标。"],
+  update_goal: ["更新任务目标", "更新当前任务的完成状态。"],
+  session_search: ["搜索历史会话", "查找当前账号可见的历史会话。"],
+  session_event_search: ["搜索会话记录", "在获准访问的会话记录中查找内容。"],
+  session_trace: ["查看会话过程", "读取指定会话的处理过程。"],
+  session_event_trace: ["查看记录过程", "读取指定会话记录的处理过程。"],
+  session_event_read: ["读取会话记录", "读取指定的会话记录。"],
+  schedule_create: ["创建定时任务", "设置后续需要执行的任务。"],
+  schedule_list: ["查看定时任务", "列出当前可见的定时任务。"],
+  schedule_update: ["调整定时任务", "修改已有定时任务的配置。"],
+  schedule_delete: ["删除定时任务", "移除指定的定时任务。"],
+  working_directory: ["查看工作目录", "确认当前任务使用的工作目录。"],
+  load_workspace_dependencies: [
+    "查看工作区能力",
+    "查看当前可用的文档与数据处理能力。",
+  ],
+  terminal_open: ["启动命令终端", "启动工作区内的命令终端。"],
+  terminal_send: ["发送终端输入", "向工作区终端发送输入。"],
+  terminal_read: ["读取终端输出", "读取工作区终端的执行结果。"],
+  terminal_signal: ["控制终端进程", "向运行中的终端进程发送控制信号。"],
+  terminal_close: ["关闭终端", "关闭指定的工作区终端。"],
+  terminal_list: ["查看终端", "列出当前可用的工作区终端。"],
+  bash: ["运行工作区命令", "在授权工作区执行命令并整理材料。"],
+  read_image: ["查看图片", "查看工作区中的图片材料。"],
+  skill: ["使用业务技能", "读取适用的工作指南并按步骤处理任务。"],
+  list_subagent_models: ["查看协作模型", "查看可用于协作任务的模型。"],
+  read: ["读取文件", "读取工作区文件的内容。"],
+  write: ["写入文件", "创建或更新工作区文件。"],
+  edit: ["编辑文件", "按指定内容修改工作区文件。"],
+  glob: ["查找文件", "按文件名或路径查找工作区材料。"],
+  grep: ["搜索文件内容", "在工作区文件中查找匹配内容。"],
+  todo_write: ["更新任务清单", "维护当前任务的进度与待办事项。"],
+  ask_user_question: ["询问信息", "向用户确认完成任务所需的信息。"],
+  present: ["展示成果", "展示已生成的文件或结果。"],
+  subagent: ["委派分析任务", "将独立分析交给协作助手处理。"],
+  send_message: ["发送协作信息", "向协作助手传递任务信息。"],
+  wait: ["等待协作结果", "等待协作助手完成任务。"],
+  wait_agent: ["等待协作结果", "等待协作助手完成任务。"],
+  run_code: ["处理工作区材料", "运行代码整理已授权的材料。"],
+};
+/** Mirrors the upstream documented server-qualified wire encoding, without changing execution names. */
+export function publicMcpName(rawName) {
+  const joined = `mcp__windy__${rawName}`;
+  const normalized = joined.replace(/[^A-Za-z0-9_-]/g, "_");
+  if (normalized === joined && normalized.length <= 64) return normalized;
+  const hash = createHash("sha256")
+    .update(`windy\0${rawName}`)
+    .digest("hex")
+    .slice(0, 12);
+  return `${normalized.slice(0, 51)}_${hash}`;
+}
+export function displayMetadata(tool, metadata = new Map()) {
+  const business = tool.name.startsWith("mcp__windy__");
+  const supplied = metadata.get(tool.name);
+  const fallback = native[tool.name];
+  const description = supplied?.description || tool.description || "";
+  return {
+    ...categoryMetadata(tool, supplied),
+    displayName:
+      supplied?.displayName ||
+      fallback?.[0] ||
+      (business ? "业务查询工具" : "工作区工具"),
+    summary:
+      fallback?.[1] ||
+      (/[\u3400-\u9fff]/.test(description) &&
+      !/DSH|DeepSeek|Harness|Schema|mcp__|discover_business_tools/i.test(
+        description,
+      )
+        ? description.split(/[\n。]/)[0].slice(0, 44)
+        : business
+          ? "查询当前账号获准访问的业务资料。"
+          : "处理当前工作区中获准使用的材料。"),
+    sourceLabel: business ? "业务工具" : "工作区工具",
+    strategyLabel: business ? "按需使用" : "默认可用",
+  };
+}
+/** Fetch display-only Manifest metadata through the existing actor-bound MCP boundary. */
+export async function loadToolMetadata(signal) {
+  const gate = process.env.WINDY_GATE_URL,
+    token = process.env.WINDY_WORKER_TOKEN;
+  if (!gate || !token) return new Map();
+  const response = await fetch(`${gate}/mcp`, {
+    method: "POST",
+    redirect: "error",
+    signal: signal
+      ? AbortSignal.any([signal, AbortSignal.timeout(5000)])
+      : AbortSignal.timeout(5000),
+    headers: {
+      authorization: `Bearer ${token}`,
+      "content-type": "application/json",
+      accept: "application/json, text/event-stream",
+    },
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      id: "windy-display-metadata",
+      method: "tools/list",
+      params: {},
+    }),
+  });
+  if (!response.ok) throw new Error("TOOL_DISPLAY_METADATA_UNAVAILABLE");
+  const value = await response.json();
+  if (!Array.isArray(value.result?.tools))
+    throw new Error("TOOL_DISPLAY_METADATA_INVALID");
+  const metadata = new Map();
+  for (const tool of value.result.tools.slice(0, 512)) {
+    const title = tool.title || tool.annotations?.title;
+    if (
+      typeof tool.name !== "string" ||
+      typeof title !== "string" ||
+      !/[\u3400-\u9fff]/.test(title)
+    )
+      continue;
+    metadata.set(publicMcpName(tool.name), {
+      displayName: title.slice(0, 60),
+      description: typeof tool.description === "string" ? tool.description : "",
+      ...(typeof tool._meta?.["windy/moduleKey"] === "string" &&
+      /^[a-z][a-z0-9.-]{0,127}$/.test(tool._meta["windy/moduleKey"]) &&
+      typeof tool._meta?.["windy/moduleLabel"] === "string" &&
+      tool._meta["windy/moduleLabel"].trim().length > 0 &&
+      tool._meta["windy/moduleLabel"].length <= 80
+        ? {
+            moduleKey: tool._meta["windy/moduleKey"],
+            moduleLabel: tool._meta["windy/moduleLabel"].trim(),
+          }
+        : {}),
+    });
+  }
+  return metadata;
+}

package/template/apps/agent-server/plugins/tool-catalog/presentation.test.ts

@@ -0,0 +1,166 @@
+import { expect, test } from "bun:test";
+import { Context } from "@deepseek-ai/cordis";
+import SystemPrompt from "@deepseek-ai/dsh-system-prompt";
+import ToolRuntime from "@deepseek-ai/dsh-tools";
+import * as Mcp from "@deepseek-ai/dsh-mcp-client";
+import {
+  displayMetadata,
+  loadToolMetadata,
+  publicMcpName,
+} from "./presentation.mjs";
+
+test("Manifest MCP titles retain their official bridge wire-name association, including hashed names", async () => {
+  const raw = ["simple_query", "case.directory.summary", "a".repeat(90)];
+  const tools = raw.map((name, index) => ({
+    name,
+    title: `业务查询${index}`,
+    description: "查询当前账号可见的资料。包含较长调用说明时仅显示首句。",
+    inputSchema: { type: "object", properties: {} },
+    _meta: {
+      "windy/moduleKey": "case",
+      "windy/moduleLabel": "案件",
+      privateScope: "never-forward",
+    },
+  }));
+  const server = Bun.serve({
+    port: 0,
+    hostname: "127.0.0.1",
+    async fetch(request) {
+      if (request.method !== "POST") return new Response(null, { status: 405 });
+      const body = await request.json();
+      if (body.id === "windy-display-metadata")
+        expect(request.headers.get("authorization")).toBe(
+          "Bearer metadata-fixture",
+        );
+      const result =
+        body.method === "initialize"
+          ? {
+              protocolVersion: body.params.protocolVersion,
+              capabilities: { tools: {} },
+              serverInfo: { name: "test", version: "1" },
+            }
+          : body.method === "tools/list"
+            ? { tools }
+            : {};
+      if (body.id === undefined) return new Response(null, { status: 202 });
+      return Response.json({ jsonrpc: "2.0", id: body.id, result });
+    },
+  });
+  const gate = process.env.WINDY_GATE_URL,
+    token = process.env.WINDY_WORKER_TOKEN;
+  const ctx = new Context();
+  const prompt = ctx.plugin(SystemPrompt, {
+    includeHarnessIdentity: false,
+    includeRuntimeContext: false,
+  });
+  await prompt.await();
+  const runtime = ctx.plugin(ToolRuntime);
+  await runtime.await();
+  const bridge = ctx.plugin(Mcp, {
+    serverName: "windy",
+    transport: "streamable-http",
+    url: `http://127.0.0.1:${server.port}/mcp`,
+    failOnStartupError: true,
+  });
+  try {
+    await bridge.await();
+    process.env.WINDY_GATE_URL = `http://127.0.0.1:${server.port}`;
+    process.env.WINDY_WORKER_TOKEN = "metadata-fixture";
+    const metadata = await loadToolMetadata();
+    expect(
+      ctx.tools
+        .schemas()
+        .map((tool) => tool.name)
+        .sort(),
+    ).toEqual(raw.map(publicMcpName).sort());
+    for (const [index, name] of raw.entries()) {
+      const display = displayMetadata({ name: publicMcpName(name) }, metadata);
+      expect(display.displayName).toBe(`业务查询${index}`);
+      expect(display.summary).toBe("查询当前账号可见的资料");
+      expect(display).toMatchObject({
+        categoryKey: "case",
+        categoryLabel: "案件",
+      });
+      expect(metadata.get(publicMcpName(name))).toMatchObject({
+        moduleKey: "case",
+        moduleLabel: "案件",
+      });
+      expect(JSON.stringify(display)).not.toContain("never-forward");
+    }
+  } finally {
+    await bridge.dispose();
+    await runtime.dispose();
+    await prompt.dispose();
+    server.stop(true);
+    if (gate === undefined) delete process.env.WINDY_GATE_URL;
+    else process.env.WINDY_GATE_URL = gate;
+    if (token === undefined) delete process.env.WINDY_WORKER_TOKEN;
+    else process.env.WINDY_WORKER_TOKEN = token;
+  }
+});
+test("native tools have Chinese names and concise summaries; unknown extensions stay safely readable", () => {
+  const names = [
+    "discover_business_tools",
+    "bash",
+    "read",
+    "read_image",
+    "write",
+    "edit",
+    "glob",
+    "grep",
+    "skill",
+    "ask_user_question",
+    "todo_write",
+    "present",
+    "subagent",
+    "send_message",
+    "interrupt_agent",
+    "wait_subagents",
+    "job_output",
+    "job_list",
+    "job_kill",
+    "get_goal",
+    "create_goal",
+    "update_goal",
+    "working_directory",
+    "load_workspace_dependencies",
+    "terminal_open",
+    "terminal_send",
+    "terminal_read",
+    "terminal_signal",
+    "terminal_close",
+    "terminal_list",
+    "session_search",
+    "session_event_search",
+    "session_trace",
+    "session_event_trace",
+    "session_event_read",
+    "schedule_create",
+    "schedule_list",
+    "schedule_update",
+    "schedule_delete",
+  ];
+  for (const name of names) {
+    const display = displayMetadata({
+      name,
+      description: "DSH DeepSeek Harness internal schema implementation",
+    });
+    expect(display.displayName).not.toBe("工作区工具");
+    expect(display.summary.length).toBeLessThanOrEqual(44);
+    expect(`${display.displayName}${display.summary}`).not.toMatch(
+      /DSH|DeepSeek|Harness|Schema/i,
+    );
+  }
+  expect(
+    displayMetadata({
+      name: "unknown_extension",
+      description: "DSH 私有Schema",
+    }).displayName,
+  ).toBe("工作区工具");
+  expect(
+    displayMetadata({
+      name: "mcp__windy__unknown",
+      description: "DSH 私有Schema",
+    }).summary,
+  ).toBe("查询当前账号获准访问的业务资料。");
+});

package/template/apps/agent-server/plugins/tool-catalog/routes.test.ts

@@ -0,0 +1,209 @@
+import { expect, test } from "bun:test";
+import type { Context } from "@deepseek-ai/cordis";
+import { apply } from "./index.mjs";
+type Request = { method: string; url: string; headers: { cookie?: string } };
+type Response = {
+  writeHead(status: number, headers?: Record<string, string>): void;
+  end(body?: string): void;
+};
+test("settings inventory is identity protected, live, bounded, and never includes parameter schemas", async () => {
+  let handler!: (request: Request, response: Response) => Promise<void>;
+  let reads = 0;
+  const tools = [
+    {
+      name: "mcp__windy__case_search",
+      description: "案件查询",
+      parameters: { secretFixture: "never-publish" },
+    },
+  ];
+  await apply({
+    tools: {
+      guard: () => {},
+      schemas: () => {
+        reads++;
+        return tools;
+      },
+      get: () => tools[0],
+    },
+    agents: { list: () => [] },
+    on: () => {},
+    effect: (run: () => void) => run(),
+    connection: {
+      requestRejection: (request: Request) =>
+        request.headers.cookie === "worker=owner" ? undefined : 401,
+    },
+    webServer: {
+      register: (route: { handler: typeof handler }) => {
+        handler = route.handler;
+      },
+    },
+  } as unknown as Context);
+  const request = async (url: string, cookie?: string, method = "GET") => {
+    let status = 0,
+      body = "",
+      headers: Record<string, string> = {};
+    await handler(
+      { url, method, headers: { cookie } },
+      {
+        writeHead: (nextStatus, nextHeaders = {}) => {
+          status = nextStatus;
+          headers = nextHeaders;
+        },
+        end: (nextBody = "") => {
+          body = nextBody;
+        },
+      },
+    );
+    return { status, body, headers };
+  };
+  reads = 0;
+  expect((await request("/windy/tool-catalog")).status).toBe(401);
+  expect(reads).toBe(0);
+  expect(
+    (await request("/windy/tool-catalog", "worker=owner", "POST")).status,
+  ).toBe(405);
+  expect(
+    (await request("/windy/tool-catalog?page=0", "worker=owner")).status,
+  ).toBe(400);
+  const initial = await request("/windy/tool-catalog", "worker=owner");
+  expect(initial.status).toBe(200);
+  expect(initial.headers["cache-control"]).toBe("no-store");
+  expect(initial.body).not.toContain("never-publish");
+  expect(JSON.parse(initial.body).items[0]).toMatchObject({
+    name: tools[0]!.name,
+    strategy: "on-demand",
+    source: "business-mcp",
+    categoryKey: "business",
+    categoryLabel: "业务工具",
+  });
+  expect(JSON.parse(initial.body).groups).toEqual([
+    { categoryKey: "business", categoryLabel: "业务工具", count: 1 },
+  ]);
+  expect(
+    JSON.parse(
+      (await request("/windy/tool-catalog?category=business", "worker=owner"))
+        .body,
+    ),
+  ).toMatchObject({ total: 1, matchedTotal: 1, category: "business" });
+  expect(
+    (await request("/windy/tool-catalog?category=private", "worker=owner"))
+      .status,
+  ).toBe(400);
+  expect(
+    (
+      await request(
+        "/windy/tool-catalog?category=" + "x".repeat(129),
+        "worker=owner",
+      )
+    ).status,
+  ).toBe(400);
+  tools.splice(0);
+  expect(
+    JSON.parse((await request("/windy/tool-catalog", "worker=owner")).body)
+      .total,
+  ).toBe(0);
+});
+
+test("metadata startup is nonblocking and a failed lookup retries on the next authenticated refresh", async () => {
+  const previousGate = process.env.WINDY_GATE_URL,
+    previousToken = process.env.WINDY_WORKER_TOKEN;
+  let finish!: () => void, started!: () => void;
+  const observed = new Promise<void>((resolve) => {
+    started = resolve;
+  });
+  const held = new Promise<void>((resolve) => {
+    finish = resolve;
+  });
+  let requests = 0;
+  const server = Bun.serve({
+    port: 0,
+    hostname: "127.0.0.1",
+    async fetch(request) {
+      expect(request.headers.get("authorization")).toBe("Bearer retry-fixture");
+      requests++;
+      if (requests === 1) {
+        started();
+        await held;
+        return new Response(null, { status: 503 });
+      }
+      return Response.json({
+        jsonrpc: "2.0",
+        id: "windy-display-metadata",
+        result: {
+          tools: [
+            {
+              name: "simple_query",
+              title: "案件查询",
+              description: "读取获准案件。",
+            },
+          ],
+        },
+      });
+    },
+  });
+  const cleanups: (() => void)[] = [];
+  let handler!: (request: Request, response: Response) => Promise<void>;
+  try {
+    process.env.WINDY_GATE_URL = `http://127.0.0.1:${server.port}`;
+    process.env.WINDY_WORKER_TOKEN = "retry-fixture";
+    const result = apply({
+      tools: {
+        schemas: () => [
+          {
+            name: "mcp__windy__simple_query",
+            description: "读取获准案件。",
+            parameters: {},
+          },
+        ],
+        get: () => undefined,
+        guard: () => {},
+      },
+      agents: { list: () => [] },
+      on: () => {},
+      effect: (run: () => () => void) => {
+        const cleanup = run();
+        if (typeof cleanup === "function") cleanups.push(cleanup);
+      },
+      connection: { requestRejection: () => undefined },
+      webServer: {
+        register: (route: { handler: typeof handler }) => {
+          handler = route.handler;
+          return () => {};
+        },
+      },
+    } as unknown as Context);
+    expect(result).toBeUndefined();
+    expect(typeof handler).toBe("function");
+    await observed;
+    const read = async () => {
+      let payload = "";
+      await handler(
+        {
+          method: "GET",
+          url: "/windy/tool-catalog",
+          headers: { cookie: "worker=owner" },
+        },
+        {
+          writeHead: () => {},
+          end: (body = "") => {
+            payload = body;
+          },
+        },
+      );
+      return JSON.parse(payload);
+    };
+    const initial = read();
+    finish();
+    expect((await initial).items[0].displayName).toBe("业务查询工具");
+    expect((await read()).items[0].displayName).toBe("案件查询");
+    expect(requests).toBe(2);
+  } finally {
+    finish();
+    for (const cleanup of cleanups.reverse()) cleanup();
+    server.stop(true);
+    if (previousGate === undefined) delete process.env.WINDY_GATE_URL;
+    else process.env.WINDY_GATE_URL = previousGate;
+    if (previousToken === undefined) delete process.env.WINDY_WORKER_TOKEN;
+    else process.env.WINDY_WORKER_TOKEN = previousToken;
+  }
+});

package/template/apps/agent-server/plugins/tool-catalog/style.css

@@ -0,0 +1,155 @@
+.windy-tool-catalog {
+  min-width: 0;
+  color: var(--dsw-alias-label-primary);
+  font-size: 0.875rem;
+}
+.windy-tool-page-head,
+.windy-tool-toolbar,
+.windy-tool-heading,
+.windy-tool-pagination {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+}
+.windy-tool-page-head {
+  justify-content: space-between;
+  align-items: flex-start;
+  margin-bottom: 20px;
+}
+/* Match the existing Plugins page hierarchy, without its implementation classes. */
+.windy-tool-catalog h2 {
+  margin: 0;
+  font-size: 1.25rem;
+  font-weight: 500;
+  line-height: 1.4;
+}
+.windy-tool-catalog .windy-tool-intro {
+  margin: 4px 0 0;
+  color: var(--dsw-alias-label-secondary);
+  font-size: 0.8125rem;
+  font-weight: 400;
+  line-height: 1.54;
+}
+.windy-tool-toolbar {
+  flex-wrap: wrap;
+  margin-bottom: 16px;
+}
+.windy-tool-search {
+  box-sizing: border-box;
+  flex: 1;
+  width: 100%;
+  min-width: min(100%, 12rem);
+  max-width: 24rem;
+}
+.windy-tool-search input {
+  width: 100%;
+  min-width: 0;
+  box-sizing: border-box;
+}
+.windy-tool-count {
+  color: var(--dsw-alias-label-tertiary);
+  font-size: 0.8125rem;
+  white-space: nowrap;
+}
+.windy-tool-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fill, minmax(min(100%, 16rem), 1fr));
+  gap: 12px;
+  margin: 0 0 16px;
+  padding: 0;
+  list-style: none;
+}
+.windy-tool-grid > li {
+  min-width: 0;
+  padding: 14px 16px;
+  border: 1px solid var(--dsw-alias-border-l2);
+  border-radius: var(--dsw-radius-lg);
+  background: var(--dsw-alias-settings-card-fill);
+}
+.windy-tool-heading {
+  justify-content: space-between;
+  align-items: flex-start;
+  flex-wrap: wrap;
+  gap: 6px 8px;
+}
+.windy-tool-heading h3 {
+  flex: 1;
+  min-width: 0;
+  margin: 0;
+  font-size: 0.875rem;
+  font-weight: 500;
+  line-height: 1.43;
+  overflow-wrap: anywhere;
+}
+.windy-tool-heading > :last-child {
+  flex: none;
+  font-size: 0.625rem;
+  font-weight: 400;
+}
+.windy-tool-catalog .windy-tool-summary {
+  display: -webkit-box;
+  -webkit-box-orient: vertical;
+  -webkit-line-clamp: 2;
+  overflow: hidden;
+  overflow-wrap: anywhere;
+  margin: 6px 0 0;
+  color: var(--dsw-alias-label-secondary);
+  font-size: 0.8125rem;
+  font-weight: 400;
+  line-height: 1.54;
+}
+.windy-tool-pagination {
+  justify-content: flex-end;
+  gap: 8px;
+  white-space: nowrap;
+  font-size: 0.75rem;
+}
+.windy-tool-catalog [role="status"],
+.windy-tool-catalog [role="alert"] {
+  font-size: 0.8125rem;
+  line-height: 1.54;
+}
+.windy-tool-catalog [role="alert"] {
+  color: var(--dsw-alias-state-error-primary);
+}
+
+.windy-tool-scopes {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 6px;
+  margin: 0 0 16px;
+}
+.windy-tool-grid > li {
+  position: relative;
+}
+.windy-tool-grid > li:has(.windy-tool-use:hover),
+.windy-tool-grid > li:has(.windy-tool-use:focus-visible) {
+  border-color: var(--dsw-alias-brand-primary);
+}
+.windy-tool-use {
+  appearance: none;
+  padding: 0;
+  border: 0;
+  background: transparent;
+  color: inherit;
+  font: inherit;
+  text-align: start;
+  cursor: pointer;
+}
+.windy-tool-use::after {
+  content: "";
+  position: absolute;
+  inset: 0;
+  border-radius: var(--dsw-radius-lg);
+}
+.windy-tool-use:focus-visible {
+  outline: none;
+}
+.windy-tool-use:focus-visible::after {
+  outline: 2px solid var(--dsw-alias-brand-primary);
+  outline-offset: 3px;
+}
+.windy-tool-use:disabled {
+  cursor: wait;
+  opacity: 0.6;
+}