create-windy 0.8.2 → 0.9.1

package/template/apps/agent-server/plugins/skill-library/style.css

@@ -0,0 +1,229 @@
+.windy-skills {
+  height: 100%;
+  overflow: auto;
+  box-sizing: border-box;
+  padding: 28px clamp(24px, 4vw, 48px) 48px;
+  color: var(--dsw-alias-label-primary);
+  background: var(--dsw-alias-bg-base);
+  font-size: 14px;
+}
+.windy-skills-content {
+  max-width: 960px;
+  margin-inline: auto;
+  min-width: 0;
+}
+.windy-skills h1 {
+  font-size: 20px;
+  font-weight: 500;
+  line-height: 28px;
+  margin: 0;
+}
+.windy-skills header,
+.windy-skills-actions,
+.windy-skill-heading {
+  display: flex;
+  gap: 8px;
+  align-items: center;
+  flex-wrap: wrap;
+}
+.windy-skills header {
+  justify-content: space-between;
+  gap: 16px;
+  margin-bottom: 24px;
+}
+.windy-skills p {
+  line-height: 1.6;
+}
+.windy-skills .windy-skills-intro {
+  margin: 4px 0 0;
+  color: var(--dsw-alias-label-secondary);
+  font-size: 13px;
+}
+.windy-skills label {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  margin-bottom: 16px;
+}
+.windy-skills .windy-skills-workspace {
+  flex-direction: row;
+  align-items: center;
+  flex-wrap: wrap;
+  gap: 12px;
+}
+.windy-skills select,
+.windy-skills textarea {
+  padding: 8px 12px;
+  border: 1px solid var(--dsw-alias-border-l2);
+  border-radius: var(--dsw-radius-md);
+  color: inherit;
+  background: var(--dsw-alias-bg-layer-1);
+  font: inherit;
+}
+.windy-skills select {
+  min-width: min(100%, 180px);
+  max-width: 100%;
+}
+.windy-skills textarea {
+  width: 100%;
+  box-sizing: border-box;
+  min-height: 280px;
+  resize: vertical;
+  line-height: 1.6;
+}
+.windy-skills :focus-visible {
+  outline: 2px solid var(--dsw-alias-link);
+  outline-offset: 2px;
+}
+.windy-skills-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fill, minmax(min(100%, 272px), 1fr));
+  gap: 16px;
+  padding: 0;
+  margin: 20px 0 0;
+  list-style: none;
+}
+.windy-skill-card {
+  display: flex;
+  flex-direction: column;
+  min-width: 0;
+  padding: 20px;
+  border: 1px solid var(--dsw-alias-border-l2);
+  border-radius: var(--dsw-radius-lg);
+  background: var(--dsw-alias-settings-card-fill);
+}
+.windy-skill-heading {
+  flex-wrap: nowrap;
+  align-items: flex-start;
+}
+.windy-skill-heading > svg {
+  flex: none;
+  color: var(--dsw-alias-label-secondary);
+}
+.windy-skill-heading h2 {
+  flex: 1;
+  min-width: 0;
+  overflow-wrap: anywhere;
+  margin: 0;
+  font-size: 15px;
+  line-height: 22px;
+  font-weight: 500;
+}
+.windy-skills small {
+  color: var(--dsw-alias-label-secondary);
+  font-size: 12px;
+  line-height: 22px;
+  white-space: nowrap;
+}
+.windy-skills .windy-skill-description {
+  flex: 1;
+  color: var(--dsw-alias-label-secondary);
+  font-size: 13px;
+  overflow-wrap: anywhere;
+  margin: 12px 0 20px;
+}
+.windy-skills .windy-skills-hint {
+  color: var(--dsw-alias-label-tertiary);
+  font-size: 12px;
+  margin: 0;
+}
+.windy-skills-actions > button {
+  white-space: nowrap;
+}
+.windy-skill-card .windy-skills-actions {
+  gap: 4px;
+}
+.windy-skills [role="alert"] {
+  color: var(--dsw-alias-state-error-primary);
+}
+.windy-skills-editor h2 {
+  font-size: 16px;
+  overflow-wrap: anywhere;
+}
+.windy-skills-form {
+  max-width: 720px;
+}
+.windy-skills-form fieldset {
+  border: 0;
+  padding: 0;
+  margin: 24px 0 0;
+  min-width: 0;
+}
+.windy-skills-form legend {
+  font-weight: 500;
+  font-size: 16px;
+  padding: 0;
+}
+.windy-skills-form label {
+  margin-bottom: 6px;
+}
+.windy-skills-form input,
+.windy-skills-form textarea {
+  width: 100%;
+  min-width: 0;
+  box-sizing: border-box;
+  padding: 8px 12px;
+  border: 1px solid var(--dsw-alias-border-l2);
+  border-radius: var(--dsw-radius-md);
+  color: inherit;
+  background: var(--dsw-alias-bg-layer-1);
+  font: inherit;
+  line-height: 1.6;
+}
+.windy-skills-form textarea {
+  min-height: 0;
+}
+.windy-skills-field {
+  margin-block: 20px;
+}
+.windy-skills .windy-skills-form-hint {
+  font-size: 13px;
+  line-height: 1.6;
+  color: var(--dsw-alias-label-secondary);
+  margin: 6px 0 12px;
+  white-space: pre-line;
+}
+.windy-skills-assist {
+  padding-block: 16px;
+  border-block: 1px solid var(--dsw-alias-border-l2);
+}
+.windy-skills-suggestion dl {
+  margin-block: 16px;
+}
+.windy-skills-suggestion dt {
+  font-weight: 500;
+  margin-top: 12px;
+}
+.windy-skills-suggestion dd {
+  margin: 4px 0 0;
+  white-space: pre-wrap;
+  overflow-wrap: anywhere;
+  line-height: 1.6;
+}
+.windy-skills-preview {
+  margin-block: 20px;
+}
+.windy-skills-preview summary {
+  cursor: pointer;
+  padding-block: 8px;
+}
+.windy-skills-preview pre {
+  white-space: pre-wrap;
+  overflow-wrap: anywhere;
+  padding: 16px;
+  background: var(--dsw-alias-bg-layer-1);
+  border: 1px solid var(--dsw-alias-border-l2);
+  border-radius: var(--dsw-radius-md);
+  font-size: 13px;
+  line-height: 1.6;
+}
+.windy-skills-save {
+  padding-block: 12px;
+}
+.windy-skills-form :disabled {
+  opacity: 0.65;
+  cursor: wait;
+}
+.windy-skills-form [aria-invalid="true"] {
+  border-color: var(--dsw-alias-state-error-primary);
+}

package/template/apps/agent-server/plugins/skill-library/test-fixture.ts

@@ -0,0 +1,77 @@
+import { afterEach } from "bun:test";
+import { mkdtemp, mkdir, realpath, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { skillResponse, type SkillContext } from "./index.mjs";
+export const cleanups: (() => Promise<unknown>)[] = [];
+afterEach(async () => {
+  for (const cleanup of cleanups.splice(0)) await cleanup();
+});
+export const markdown = (name = "my-skill") =>
+  `---\nname: ${name}\ndescription: 只处理当前用户主动选择的材料\nuser-invocable: true\ndisable-model-invocation: true\n---\n保留来源，核查结果。\n`;
+export async function fixture() {
+  const temporary = await mkdtemp(join(tmpdir(), "windy-skills-"));
+  cleanups.push(() => rm(temporary, { recursive: true, force: true }));
+  const base = await realpath(temporary),
+    root = join(base, "owner"),
+    other = join(base, "other"),
+    defaults = join(base, "defaults");
+  for (const path of [root, other, defaults]) await mkdir(path);
+  await mkdir(join(defaults, "default-skill"));
+  await writeFile(
+    join(defaults, "default-skill", "SKILL.md"),
+    markdown("default-skill"),
+  );
+  const config = { enabled: true, defaultSkillDir: defaults };
+  const ctx: SkillContext = {
+    tools: { register: () => () => {} },
+    userQuestions: { ask: async () => ({ answers: [] }) },
+    workingDirectory: { get: () => root },
+    connection: {
+      requestRejection(request) {
+        const headers = request.headers;
+        const cookie =
+          headers instanceof Headers ? headers.get("cookie") : headers.cookie;
+        const origin =
+          headers instanceof Headers ? headers.get("origin") : headers.origin;
+        return cookie === "native=owner" && origin === "http://localhost"
+          ? undefined
+          : 403;
+      },
+    },
+    workspaceRegistry: {
+      list: () => [{ id: "owner-workspace", path: root }],
+      get: (id) =>
+        id === "owner-workspace"
+          ? { path: root }
+          : id === "other-workspace"
+            ? { path: other }
+            : undefined,
+    },
+    sandboxPolicy: { workspaceRoot: root },
+    on() {},
+    effect(callback) {
+      callback();
+    },
+    webServer: {
+      register() {
+        return () => {};
+      },
+    },
+  };
+  async function call(
+    body: Record<string, unknown>,
+    headers = { cookie: "native=owner", origin: "http://localhost" },
+  ) {
+    return skillResponse(
+      ctx,
+      config,
+      new Request("http://localhost/windy/skills", {
+        method: "POST",
+        headers: { ...headers, "content-type": "application/json" },
+        body: JSON.stringify({ workspaceId: "owner-workspace", ...body }),
+      }),
+    );
+  }
+  return { root, other, defaults, ctx, config, call };
+}

package/template/apps/agent-server/plugins/skill-library/workflow.d.mts

@@ -0,0 +1,18 @@
+import type { ToolRunContext } from "@deepseek-ai/dsh-tools";
+import type { SkillContext, SkillConfig } from "./index.mjs";
+export const workflowToolName: "save_workflow_skill";
+export function workflowDocument(args: unknown): {
+  name: string;
+  displayName: string;
+  raw: string;
+};
+export function saveWorkflowSkill(
+  ctx: SkillContext,
+  config: SkillConfig,
+  args: unknown,
+  execution: Pick<ToolRunContext, "agent" | "signal">,
+): Promise<Record<string, unknown>>;
+export function registerWorkflowTool(
+  ctx: SkillContext,
+  config: SkillConfig,
+): void;

package/template/apps/agent-server/plugins/skill-library/workflow.mjs

@@ -0,0 +1,189 @@
+import { createHash } from "node:crypto";
+import { resolve } from "node:path";
+import { realpath } from "node:fs/promises";
+import { fail, markdownBundle } from "./bundle.mjs";
+import {
+  contained,
+  installSkill,
+  listSkills,
+  readSkill,
+  skillRoots,
+} from "./storage.mjs";
+
+export const workflowToolName = "save_workflow_skill";
+const constraints =
+  "只使用当前用户获准的工具和工作文件，保留来源并核验输出。技能不授予权限；不得直连业务数据库、绕过审批或复制凭据。业务对象使用本次执行的参数，不把示例当成真实事实。取消后停止后续操作。";
+function hasControls(text) {
+  return [...text].some((char) => {
+    const code = char.charCodeAt(0);
+    return (code < 32 && ![9, 10, 13].includes(code)) || code === 127;
+  });
+}
+export function workflowDocument(args) {
+  if (
+    !args ||
+    typeof args !== "object" ||
+    Array.isArray(args) ||
+    Object.keys(args).some(
+      (key) => !["name", "description", "workflow"].includes(key),
+    )
+  )
+    fail("技能参数无效。");
+  for (const [key, max] of [
+    ["name", 60],
+    ["description", 2048],
+    ["workflow", 16000],
+  ]) {
+    if (
+      typeof args[key] !== "string" ||
+      !args[key].trim() ||
+      args[key].length > max ||
+      hasControls(args[key])
+    )
+      fail("请填写完整的技能名称、说明与通用步骤。");
+  }
+  const displayName = args.name.trim().normalize("NFC");
+  if (
+    /[\r\n\t/\\]/.test(displayName) ||
+    displayName === "." ||
+    displayName === ".."
+  )
+    fail("技能名称须为单行文字，不能包含路径。");
+  const name = /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(displayName)
+    ? displayName
+    : `workflow-${createHash("sha256").update(displayName).digest("hex").slice(0, 16)}`;
+  const raw = [
+    "---",
+    `name: ${name}`,
+    `description: ${JSON.stringify(args.description.trim())}`,
+    "metadata:",
+    `  displayName: ${JSON.stringify(displayName)}`,
+    "user-invocable: true",
+    "disable-model-invocation: true",
+    "---",
+    "",
+    `# ${displayName}`,
+    "",
+    args.workflow.trim(),
+    "",
+    "## 授权与核验",
+    "",
+    constraints,
+    "",
+  ].join("\n");
+  return { name, displayName, raw };
+}
+
+async function workspaceFor(ctx, execution) {
+  if (!execution.agent?.session) fail("缺少当前会话。", 403);
+  const cwd = await realpath(ctx.workingDirectory.get(execution.agent.session));
+  const root = await realpath(ctx.sandboxPolicy.workspaceRoot);
+  if (!contained(root, cwd)) fail("工作区不属于当前用户。", 403);
+  const workspace = ctx.workspaceRegistry
+    .list()
+    .find((item) => resolve(item.path) === cwd);
+  if (!workspace) fail("请在当前工作区创建会话后保存技能。", 404);
+  return workspace.id;
+}
+async function assertAvailable(roots, draft) {
+  const items = await listSkills(roots);
+  if (
+    items.some(
+      (item) =>
+        item.name === draft.name ||
+        item.displayName.normalize("NFC") === draft.displayName,
+    )
+  )
+    fail("同名技能已存在，请更名后保存；不会覆盖已有技能。", 409);
+}
+
+export async function saveWorkflowSkill(ctx, config, args, execution) {
+  if (!config.enabled) fail("当前部署未开放个人技能管理。", 403);
+  execution.signal.throwIfAborted();
+  const draft = workflowDocument(args);
+  const workspaceId = await workspaceFor(ctx, execution);
+  await skillRoots(ctx, config, workspaceId, (roots) =>
+    assertAvailable(roots, draft),
+  );
+  const answer = await ctx.userQuestions.ask({
+    agent: execution.agent,
+    signal: execution.signal,
+    questions: [
+      {
+        id: "save-skill",
+        header: "保存个人技能",
+        question: `将“${draft.displayName}”保存到当前工作区的个人技能？请核对下方完整内容已去除本轮具体资料（包括合成示例）、案件标识和凭据。`,
+        detail: draft.raw,
+        options: [
+          {
+            label: "保存个人技能",
+            description: "仅当前用户工作区可用，不发布或共享。",
+          },
+          {
+            label: "暂不保存",
+            description: "保留当前会话，修改内容后可重新提出。",
+          },
+        ],
+      },
+    ],
+  });
+  execution.signal.throwIfAborted();
+  const choice = answer.answers?.find((item) => item.id === "save-skill");
+  if (
+    answer.answers?.length !== 1 ||
+    choice?.selected?.length !== 1 ||
+    choice.selected[0] !== "保存个人技能" ||
+    choice.custom?.trim()
+  )
+    return {
+      status: "cancelled",
+      name: draft.name,
+      displayName: draft.displayName,
+    };
+  if ((await workspaceFor(ctx, execution)) !== workspaceId)
+    fail("会话工作区已变化，请重新确认。", 409);
+  return skillRoots(ctx, config, workspaceId, async (roots) => {
+    execution.signal.throwIfAborted();
+    await assertAvailable(roots, draft);
+    await installSkill(roots, markdownBundle(draft.raw));
+    const saved = await readSkill(roots.personal, draft.name);
+    return {
+      status: "saved",
+      name: saved.name,
+      displayName: saved.displayName,
+      version: saved.version,
+      path: `.dsh/skills/${saved.name}/SKILL.md`,
+      invocation: `/${saved.name}`,
+      scope: "current-user-workspace",
+      published: false,
+    };
+  });
+}
+
+export function registerWorkflowTool(ctx, config) {
+  ctx.effect(() =>
+    ctx.tools.register({
+      name: workflowToolName,
+      description:
+        "用户明确要求将刚刚完成的流程沉淀为技能时调用。name保留用户给出的中文或英文名称；description写触发条件；workflow写输入参数、已验证步骤、输出格式、验证和边界。先剔除真实身份、案件ID、账号、原始材料及凭据；本轮合成或演示数据、金额算式、编号和路径也必须替换为输入参数，不作为示例固化。只保留用户明确要求的通用常量，不记录失败尝试或未经验证的参数用法。工具会向用户展示完整内容并确认后保存到当前用户工作区；同名不覆盖，不执行或公开发布技能。",
+      parameters: {
+        type: "object",
+        additionalProperties: false,
+        required: ["name", "description", "workflow"],
+        properties: {
+          name: { type: "string", minLength: 1, maxLength: 60 },
+          description: { type: "string", minLength: 1, maxLength: 2048 },
+          workflow: { type: "string", minLength: 1, maxLength: 16000 },
+        },
+      },
+      output: {
+        schema: { type: "object", additionalProperties: true },
+        render: (_args, value) => [
+          { type: "text", text: JSON.stringify(value) },
+        ],
+      },
+      execute: (args, execution) =>
+        saveWorkflowSkill(ctx, config, args, execution),
+    }),
+  );
+}

package/template/apps/agent-server/plugins/skill-library/workflow.test.ts

@@ -0,0 +1,164 @@
+import { expect, test } from "bun:test";
+import { Context } from "@deepseek-ai/cordis";
+import type { Agent } from "@deepseek-ai/dsh-agent";
+import { FileSystemSkillProvider } from "@deepseek-ai/dsh-skill-filesystem";
+import { join } from "node:path";
+import { readFile, readdir } from "node:fs/promises";
+import { saveWorkflowSkill, workflowDocument } from "./workflow.mjs";
+import { fixture } from "./test-fixture";
+
+const args = {
+  name: "每周案件简报",
+  description: "在用户需要每周汇总授权材料时使用。",
+  workflow:
+    "输入：本次用户选定材料。\n1. 核对范围并保留来源。\n2. 生成简报并回读核验。\n输出：附来源的简报。",
+};
+const consent = { answers: [{ id: "save-skill", selected: ["保存个人技能"] }] };
+const execution = () => ({
+  agent: { session: {} } as Agent,
+  signal: new AbortController().signal,
+});
+
+test("Chinese workflow name is reviewed, saved to current workspace, read back and discovered by official provider", async () => {
+  const f = await fixture();
+  let asked = 0;
+  f.ctx.userQuestions.ask = async (request) => {
+    asked++;
+    expect(request.questions[0]?.detail).toBe(workflowDocument(args).raw);
+    expect((await f.call({ action: "list" })).status).toBe(200);
+    expect(await readdir(join(f.root, ".dsh", "skills"))).toEqual([]);
+    return consent;
+  };
+  const result = await saveWorkflowSkill(f.ctx, f.config, args, execution());
+  expect(asked).toBe(1);
+  expect(result).toMatchObject({
+    status: "saved",
+    displayName: args.name,
+    scope: "current-user-workspace",
+    published: false,
+  });
+  expect(result.name).toMatch(/^workflow-[a-f0-9]{16}$/);
+  const raw = await readFile(join(f.root, String(result.path)), "utf8");
+  expect(raw).toContain("disable-model-invocation: true");
+  expect(raw).toContain("user-invocable: true");
+  const provider = new FileSystemSkillProvider(
+    new Context(),
+    { signal: execution().signal, invalidate() {} },
+    {
+      watch: false,
+      dshHome: join(f.root, "empty-home"),
+      agentsHome: join(f.root, "empty-agents"),
+      customSkillDirs: [f.defaults],
+    },
+  );
+  try {
+    const observation = await provider.list({ cwd: f.root });
+    const rows = Array.isArray(observation)
+      ? observation
+      : observation.candidates;
+    const candidate = rows.find((row) => row.name === result.name);
+    expect(candidate?.invocation).toEqual({
+      modelInvocable: false,
+      userInvocable: true,
+    });
+    const skill = await provider.get(candidate!, { cwd: f.root });
+    expect(skill?.content).toContain(args.workflow);
+    expect(skill?.metadata?.displayName).toBe(args.name);
+  } finally {
+    await provider.dispose();
+  }
+  await expect(
+    saveWorkflowSkill(f.ctx, f.config, args, execution()),
+  ).rejects.toMatchObject({ status: 409 });
+  expect(asked).toBe(1);
+  expect(await readFile(join(f.root, String(result.path)), "utf8")).toBe(raw);
+});
+
+test("decline, free text and abort cannot publish a skill", async () => {
+  const f = await fixture();
+  for (const response of [
+    { answers: [{ id: "save-skill", selected: ["暂不保存"] }] },
+    { answers: [{ id: "save-skill", selected: [], custom: "先修改" }] },
+    {
+      answers: [
+        { id: "save-skill", selected: ["保存个人技能"], custom: "先修改" },
+      ],
+    },
+  ]) {
+    f.ctx.userQuestions.ask = async () => response;
+    expect(
+      await saveWorkflowSkill(f.ctx, f.config, args, execution()),
+    ).toMatchObject({ status: "cancelled" });
+  }
+  const controller = new AbortController();
+  f.ctx.userQuestions.ask = async () => {
+    controller.abort();
+    return consent;
+  };
+  await expect(
+    saveWorkflowSkill(f.ctx, f.config, args, {
+      ...execution(),
+      signal: controller.signal,
+    }),
+  ).rejects.toThrow();
+  expect(await readdir(join(f.root, ".dsh", "skills"))).toEqual([]);
+});
+
+test("invalid input, disabled feature, foreign workspace and changed workspace fail closed", async () => {
+  const f = await fixture();
+  let asked = 0;
+  f.ctx.userQuestions.ask = async () => {
+    asked++;
+    return consent;
+  };
+  for (const name of ["", "../other", "first\nsecond", "x".repeat(61)])
+    await expect(
+      saveWorkflowSkill(f.ctx, f.config, { ...args, name }, execution()),
+    ).rejects.toThrow();
+  await expect(
+    saveWorkflowSkill(
+      f.ctx,
+      f.config,
+      { ...args, workspaceId: "other" },
+      execution(),
+    ),
+  ).rejects.toThrow();
+  await expect(
+    saveWorkflowSkill(
+      f.ctx,
+      { ...f.config, enabled: false },
+      args,
+      execution(),
+    ),
+  ).rejects.toMatchObject({ status: 403 });
+  f.ctx.workingDirectory.get = () => f.other;
+  await expect(
+    saveWorkflowSkill(f.ctx, f.config, args, execution()),
+  ).rejects.toMatchObject({ status: 403 });
+  expect(asked).toBe(0);
+  f.ctx.workingDirectory.get = () => f.root;
+  f.ctx.userQuestions.ask = async () => {
+    f.ctx.workingDirectory.get = () => f.other;
+    return consent;
+  };
+  await expect(
+    saveWorkflowSkill(f.ctx, f.config, args, execution()),
+  ).rejects.toMatchObject({ status: 403 });
+  expect(await readdir(join(f.root, ".dsh", "skills"))).toEqual([]);
+});
+
+test("English names remain invocable and default skills cannot be overwritten", async () => {
+  const f = await fixture();
+  f.ctx.userQuestions.ask = async () => consent;
+  expect(workflowDocument({ ...args, name: "weekly-brief" }).name).toBe(
+    "weekly-brief",
+  );
+  await expect(
+    saveWorkflowSkill(
+      f.ctx,
+      f.config,
+      { ...args, name: "default-skill" },
+      execution(),
+    ),
+  ).rejects.toMatchObject({ status: 409 });
+});

package/template/apps/agent-server/plugins/skills/README.md

@@ -0,0 +1,5 @@
+# Windy 通用技能
+
+只读默认技能包括文档处理、资料对照、数据汇总、显式方法沉淀和个人扩展指南。工作方法不包含业务事实，不授予权限；项目领域技能通过 `project/host.ts` 提供。
+
+个人技能位于当前用户工作区 `.dsh/skills`。共享技能由产品后台导入发布并记录版本、范围、摘要及审计，不能通过个人安装获得组织发布身份。技能执行始终受当前工具授权、审批和数据范围约束。

package/template/apps/agent-server/plugins/skills/windy-data-summary/SKILL.md

@@ -0,0 +1,14 @@
+---
+name: windy-data-summary
+description: 对授权工作文件或真实工具结果进行有界统计与核算。
+metadata:
+  displayName: 数据汇总
+user-invocable: true
+disable-model-invocation: false
+---
+
+# 数据汇总
+
+明确字段、单位、时间和去重规则；使用实际发现的授权工具或本地计算。分页未完整时说明覆盖范围。独立回算分组和合计，保留原始编号与前导零。
+
+所有技能只使用当前用户获准的工具和文件，不授予权限，不能直连业务数据库，不绕过审批。保留来源和原件，取消后停止后续操作。