feat: import Chinese-localized Buzz source snapshot

Signed-off-by: cls_宁波本机 <908705107@qq.com>

desktop/tests/e2e/smoke.spec.ts

@@ -0,0 +1,607 @@
+import { expect, test } from "@playwright/test";
+
+import { installMockBridge, openCreateChannelDialog } from "../helpers/bridge";
+
+async function getTimelineMetrics(page: import("@playwright/test").Page) {
+  return page.getByTestId("message-timeline").evaluate((element) => {
+    const timeline = element as HTMLDivElement;
+
+    return {
+      clientHeight: timeline.clientHeight,
+      scrollHeight: timeline.scrollHeight,
+      scrollTop: timeline.scrollTop,
+      distanceFromBottom:
+        timeline.scrollHeight - timeline.clientHeight - timeline.scrollTop,
+    };
+  });
+}
+
+async function ensureTimelineScrollable(
+  page: import("@playwright/test").Page,
+  prefix: string,
+) {
+  const input = page.getByTestId("message-input");
+  const sendButton = page.getByTestId("send-message");
+
+  for (let index = 0; index < 24; index += 1) {
+    const metrics = await getTimelineMetrics(page);
+    if (metrics.scrollHeight > metrics.clientHeight + 160) {
+      return;
+    }
+
+    const message = `${prefix} seed ${index}`;
+
+    await input.fill(message);
+    await sendButton.click();
+    await expect(page.getByTestId("message-timeline")).toContainText(message);
+  }
+
+  const metrics = await getTimelineMetrics(page);
+  expect(metrics.scrollHeight).toBeGreaterThan(metrics.clientHeight + 160);
+}
+
+async function focusSidebarSearchWithShortcut(
+  page: import("@playwright/test").Page,
+) {
+  const openSearchButton = page.getByTestId("open-search");
+
+  await expect(openSearchButton).toBeVisible();
+  await page.evaluate(() => {
+    const isMac = /mac|iphone|ipad|ipod/i.test(navigator.platform);
+    window.dispatchEvent(
+      new KeyboardEvent("keydown", {
+        bubbles: true,
+        cancelable: true,
+        code: "KeyK",
+        ctrlKey: !isMac,
+        key: "k",
+        metaKey: isMac,
+      }),
+    );
+  });
+  await expect(page.getByTestId("search-results")).toBeVisible();
+  await expect(page.getByTestId("search-dialog-input")).toBeFocused();
+}
+
+async function expectHomeView(page: import("@playwright/test").Page) {
+  await expect(page.getByTestId("home-inbox-list")).toBeVisible();
+}
+
+async function selectHomeInboxFilter(
+  page: import("@playwright/test").Page,
+  label: "Agents",
+) {
+  await page
+    .getByTestId("home-inbox")
+    .getByRole("button", {
+      name: /^Filter inbox:/,
+    })
+    .click();
+  await page.getByRole("menuitemradio", { name: label }).click();
+}
+
+test.beforeEach(async ({ page }) => {
+  await installMockBridge(page);
+});
+
+test("loads the app shell with mocked channels", async ({ page }) => {
+  await page.goto("/");
+
+  await expect(page.getByTestId("app-sidebar")).toBeVisible();
+  await expect(page.getByTestId("stream-list")).toContainText("general");
+  await expect(page.getByTestId("forum-list")).toContainText("watercooler");
+  await expect(page.getByTestId("dm-list")).toContainText("alice-tyler");
+});
+
+async function chooseSharedComputeProvider(
+  page: import("@playwright/test").Page,
+) {
+  await page.getByRole("tab", { name: "Customize for this agent" }).click();
+  const provider = page.locator("#persona-llm-provider");
+  await expect(provider).toBeVisible({ timeout: 10_000 });
+  await provider.press("Enter");
+  await page
+    .getByRole("menuitemradio", {
+      exact: true,
+      name: "Buzz shared compute",
+    })
+    .click();
+}
+
+test("creates a new mocked stream", async ({ page }) => {
+  const channelName = `release-notes-${Date.now()}`;
+
+  await page.goto("/");
+  await openCreateChannelDialog(page);
+  await page.getByTestId("create-channel-name").fill(channelName);
+  await page
+    .getByTestId("create-channel-description")
+    .fill("Release coordination");
+  await page.getByTestId("create-channel-submit").click();
+
+  await expect(page.getByTestId("stream-list")).toContainText(channelName);
+  await expect(page.getByTestId("chat-title")).toContainText(channelName);
+});
+
+test("Buzz shared compute explains automatic model selection", async ({
+  page,
+}) => {
+  await page.goto("/");
+  await page.evaluate(() => {
+    (
+      window as Window & {
+        __BUZZ_E2E_SET_MESH__?: (mesh: {
+          models?: Array<{ id: string; name: string | null }>;
+        }) => void;
+      }
+    ).__BUZZ_E2E_SET_MESH__?.({ models: [] });
+  });
+  await page.getByTestId("open-agents-view").click();
+  await page.getByTestId("new-agent-card").click();
+  await chooseSharedComputeProvider(page);
+
+  await expect
+    .poll(() =>
+      page.evaluate(
+        () =>
+          (window as Window & { __BUZZ_E2E_COMMANDS__?: string[] })
+            .__BUZZ_E2E_COMMANDS__ ?? [],
+      ),
+    )
+    .toContain("discover_agent_models");
+  await expect(page.locator("#persona-model")).toContainText("Automatic");
+  await expect(
+    page.getByText(
+      "Auto uses Mesh collective intelligence when two or more models stay available, otherwise it chooses one available model.",
+    ),
+  ).toBeVisible();
+  await expect(page.locator("#persona-custom-model")).toHaveCount(0);
+});
+
+test("create agent persists Buzz shared compute with auto model", async ({
+  page,
+}) => {
+  const agentName = `Shared compute agent ${Date.now()}`;
+
+  await page.goto("/");
+  await page.getByTestId("open-agents-view").click();
+  await page.getByTestId("new-agent-card").click();
+  await page.locator("#persona-display-name").fill(agentName);
+
+  await chooseSharedComputeProvider(page);
+
+  const model = page.locator("#persona-model");
+  await expect(model).toContainText("Automatic");
+  await page.getByTestId("persona-dialog-submit").click();
+  const createdToast = page
+    .locator("[data-sonner-toast][data-removed='false']")
+    .filter({ hasText: "Agent created" });
+  await expect(createdToast).toBeVisible({ timeout: 10_000 });
+  await expect(createdToast).toHaveCount(1);
+  await expect(page.getByRole("dialog")).toHaveCount(0);
+
+  const createPayload = await page.evaluate((name) => {
+    const log = (
+      window as Window & {
+        __BUZZ_E2E_COMMAND_LOG__?: Array<{
+          command: string;
+          payload: unknown;
+        }>;
+      }
+    ).__BUZZ_E2E_COMMAND_LOG__;
+    return log
+      ?.filter((entry) => entry.command === "create_managed_agent")
+      .map((entry) => entry.payload as { input?: Record<string, unknown> })
+      .find((payload) => payload.input?.name === name)?.input;
+  }, agentName);
+
+  expect(createPayload).toMatchObject({
+    agentCommand: "buzz-agent",
+    model: "auto",
+    provider: "relay-mesh",
+    spawnAfterCreate: true,
+    startOnAppLaunch: true,
+  });
+});
+
+test("create agent supports parallelism and system prompt overrides", async ({
+  page,
+}) => {
+  const agentName = `Parallel agent ${Date.now()}`;
+
+  await page.goto("/");
+  await page.getByTestId("open-agents-view").click();
+  await page.getByTestId("new-agent-card").click();
+
+  await page.locator("#persona-display-name").fill(agentName);
+  await page
+    .locator("#persona-system-prompt")
+    .fill("You are concise and parallelize independent work.");
+
+  // The buzz-agent runtime auto-selects once the ACP runtime catalog loads;
+  // Customize reveals the per-agent LLM provider and model fields.
+  await page.getByRole("tab", { name: "Customize for this agent" }).click();
+  const llmProvider = page.locator("#persona-llm-provider");
+  await expect(llmProvider).toBeVisible({ timeout: 10_000 });
+  await llmProvider.press("Enter");
+  await page
+    .getByRole("menuitemradio", { exact: true, name: "Anthropic" })
+    .click();
+  const model = page.locator("#persona-model");
+  await model.click();
+  await page
+    .getByRole("button", { name: "Custom model...", exact: true })
+    .click();
+  await page.getByLabel("Custom model ID").fill("claude-opus-4-5");
+  await page.getByLabel("Anthropic API Key").fill("sk-test-api-key-for-e2e");
+
+  const advancedToggle = page.getByRole("button", {
+    name: "Advanced",
+    exact: true,
+  });
+  await advancedToggle.click();
+  // Parallelism is above the env-vars editor in the Advanced section; filling
+  // the required API-key row may have scrolled the dialog past it. Scroll back.
+  await page
+    .locator("#persona-parallelism")
+    .evaluate((el) => el.scrollIntoView({ block: "nearest" }));
+  await expect(page.locator("#persona-parallelism")).toBeVisible();
+  await page.locator("#persona-parallelism").fill("3");
+
+  // Submitting mints a running instance whose behavioral quad resolves from
+  // the definition (agents always start after creation).
+  await page.getByTestId("persona-dialog-submit").click();
+
+  const createdToast = page
+    .locator("[data-sonner-toast][data-removed='false']")
+    .filter({ hasText: "Agent created" });
+  await expect(createdToast).toBeVisible({ timeout: 10_000 });
+  await expect(createdToast).toHaveCount(1);
+  await expect(page.getByRole("dialog")).toHaveCount(0);
+
+  await expect(page.getByTestId("agents-library-personas")).toContainText(
+    agentName,
+  );
+
+  // Logs now live in the profile sidebar (PR #1274), not an inline panel.
+  // Open the new agent's card to reveal the profile panel, then read the
+  // harness log from the diagnostics view.
+  await page
+    .getByRole("button", { name: `${agentName} agent profile` })
+    .click();
+  await expect(page.getByTestId("user-profile-panel")).toBeVisible();
+
+  await page.getByTestId("user-profile-tab-runtime").click();
+  await page.getByTestId("user-profile-diagnostics-ingress").click();
+
+  const log = page.getByTestId("managed-agent-log-content");
+  await expect(log).toContainText("parallelism=3");
+  await expect(log).toContainText("system prompt override configured");
+});
+
+test("opens a mocked channel from the inbox feed", async ({ page }) => {
+  const inboxList = page.getByTestId("home-inbox-list");
+
+  await page.goto("/");
+
+  await expectHomeView(page);
+  await expect(inboxList).toContainText("Please review the release checklist.");
+
+  const releaseRow = page.getByTestId("home-inbox-item-mock-feed-mention");
+  await releaseRow.hover();
+  await releaseRow.getByRole("button", { name: "Open in channel" }).click();
+
+  await expect(page).toHaveURL(
+    /#\/channels\/9a1657ac-f7aa-5db0-b632-d8bbeb6dfb50\?messageId=mock-feed-mention$/,
+  );
+  await expect(page.getByTestId("chat-title")).toHaveText("general");
+});
+
+test("Inbox excludes generic channel and unowned agent traffic", async ({
+  page,
+}) => {
+  const inboxList = page.getByTestId("home-inbox-list");
+
+  await page.goto("/");
+  await expectHomeView(page);
+
+  await expect(inboxList).not.toContainText(
+    "Engineering shipped the desktop build.",
+  );
+  await expect(inboxList).not.toContainText(
+    "Agent progress: channel index complete.",
+  );
+
+  await selectHomeInboxFilter(page, "Agents");
+  await expect(inboxList).toContainText("No agent updates found");
+});
+
+test("inbox feed renders resolved author labels", async ({ page }) => {
+  await page.goto("/");
+
+  await expect(page.getByTestId("home-inbox-list")).toContainText("alice");
+  await expect(page.getByTestId("home-inbox-list")).not.toContainText("You");
+});
+
+test("opens sidebar search with the shortcut and loads the exact result", async ({
+  page,
+}) => {
+  await page.goto("/");
+
+  await focusSidebarSearchWithShortcut(page);
+
+  await page.getByTestId("search-dialog-input").fill("shipped");
+  await expect(page.getByTestId("search-results")).toContainText(
+    "Engineering shipped the desktop build.",
+  );
+
+  await page.keyboard.press("Enter");
+
+  await expect(page).toHaveURL(
+    /#\/channels\/1c7e1c02-87bb-5e88-b2da-5a7a9432d0c9\?messageId=mock-engineering-shipped$/,
+  );
+  await expect(page.getByTestId("chat-title")).toHaveText("engineering");
+  await expect(page.getByTestId("message-timeline")).toContainText(
+    "Engineering shipped the desktop build.",
+  );
+});
+
+test("opens channel matches from search", async ({ page }) => {
+  await page.goto("/");
+
+  await focusSidebarSearchWithShortcut(page);
+
+  await page.getByTestId("search-dialog-input").fill("engineering");
+  const results = page.getByTestId("search-results");
+
+  await expect(results).toContainText("engineering");
+  await expect(results).toContainText("Engineering discussions");
+  await expect(results).toContainText(
+    "Design system and UX discussions with engineering partners",
+  );
+  await expect(
+    results.locator('[data-testid^="search-result-channel-"]').first(),
+  ).toHaveAttribute(
+    "data-testid",
+    "search-result-channel-1c7e1c02-87bb-5e88-b2da-5a7a9432d0c9",
+  );
+
+  await expect(
+    results.getByTestId(
+      "search-result-channel-1c7e1c02-87bb-5e88-b2da-5a7a9432d0c9",
+    ),
+  ).toHaveAttribute("aria-selected", "true");
+  await page.keyboard.press("Enter");
+
+  await expect(page).toHaveURL(
+    /#\/channels\/1c7e1c02-87bb-5e88-b2da-5a7a9432d0c9$/,
+  );
+  await expect(page.getByTestId("chat-title")).toHaveText("engineering");
+});
+
+test("closes sidebar search with Escape", async ({ page }) => {
+  await page.goto("/");
+
+  await focusSidebarSearchWithShortcut(page);
+  await page.getByTestId("search-dialog-input").fill("shipped");
+
+  await page.keyboard.press("Escape");
+
+  await expect(page.getByTestId("search-results")).toHaveCount(0);
+  await expect(page.getByTestId("open-search")).toBeFocused();
+});
+
+test("search shortcut opens search without disturbing the collapsed sidebar", async ({
+  page,
+}) => {
+  await page.goto("/");
+
+  await expect(page.getByTestId("open-search")).toBeVisible();
+
+  const sidebarRoot = page.locator('[data-side="left"][data-state]');
+  await expect(sidebarRoot).toHaveAttribute("data-state", "expanded");
+
+  // Collapse the sidebar; its pinned-header search slides off-screen.
+  await page
+    .getByRole("button", { name: "Toggle Sidebar", exact: true })
+    .click();
+  await expect(sidebarRoot).toHaveAttribute("data-state", "collapsed");
+
+  await page.evaluate(() => {
+    const isMac = /mac|iphone|ipad|ipod/i.test(navigator.platform);
+    window.dispatchEvent(
+      new KeyboardEvent("keydown", {
+        bubbles: true,
+        cancelable: true,
+        code: "KeyK",
+        ctrlKey: !isMac,
+        key: "k",
+        metaKey: isMac,
+      }),
+    );
+  });
+
+  // Search opens in its portal dialog; the sidebar must not react.
+  await expect(page.getByTestId("search-dialog-input")).toBeFocused();
+  await expect(sidebarRoot).toHaveAttribute("data-state", "collapsed");
+});
+
+test("search results use your resolved profile label instead of You", async ({
+  page,
+}) => {
+  await page.goto("/");
+
+  await focusSidebarSearchWithShortcut(page);
+
+  await page.getByTestId("search-dialog-input").fill("welcome");
+  const results = page.getByTestId("search-results");
+
+  await expect(results).toContainText("Welcome to #general");
+  await expect(results).toContainText("npub1mock...");
+  await expect(results).not.toContainText("You");
+});
+
+test("opens accessible unjoined channels from search in read-only mode", async ({
+  page,
+}) => {
+  await page.goto("/");
+
+  await focusSidebarSearchWithShortcut(page);
+
+  await page.getByTestId("search-dialog-input").fill("critique");
+  const results = page.getByTestId("search-results");
+
+  await expect(results).toContainText(
+    "Design critique notes for the browse flow.",
+  );
+  await results.getByText("Design critique notes for the browse flow.").click();
+
+  await expect(page.getByTestId("chat-title")).toHaveText("design");
+  await expect(page.getByTestId("message-timeline")).toContainText(
+    "Design critique notes for the browse flow.",
+  );
+  await expect(page.getByTestId("join-banner")).toBeVisible();
+});
+
+test("replaces the channel pane when switching channels", async ({ page }) => {
+  await page.goto("/");
+
+  await page.getByTestId("channel-general").click();
+  await expect(page.getByTestId("chat-title")).toHaveText("general");
+  await expect(page.getByTestId("message-timeline")).toContainText(
+    "Welcome to #general",
+  );
+
+  await page.getByTestId("channel-random").click();
+  await expect(page.getByTestId("chat-title")).toHaveText("random");
+  await expect(page.getByTestId("message-channel-intro")).toBeVisible();
+  await expect(page.getByTestId("message-channel-intro")).toContainText(
+    "This is the beginning of the regular channel.",
+  );
+  await expect(page.getByTestId("message-timeline")).not.toContainText(
+    "Welcome to #general",
+  );
+  await expect(page.getByTestId("message-timeline")).toHaveCount(1);
+  await expect(page.getByTestId("message-timeline-day-divider")).toHaveCount(0);
+
+  await page.getByTestId("channel-engineering").click();
+  await expect(page.getByTestId("chat-title")).toHaveText("engineering");
+  await expect(page.getByTestId("message-channel-intro")).toBeVisible();
+  await expect(page.getByTestId("message-timeline")).toHaveCount(1);
+  await expect(page.getByTestId("message-timeline-day-divider")).toHaveCount(0);
+});
+
+test("sends a mocked channel message", async ({ page }) => {
+  const message = `Smoke message ${Date.now()}`;
+
+  await page.goto("/");
+  await page.getByTestId("channel-general").click();
+  await expect(page.getByTestId("chat-title")).toHaveText("general");
+  await page.getByTestId("message-input").fill(message);
+  await page.getByTestId("send-message").click();
+
+  await expect(page.getByTestId("message-timeline")).toContainText(message);
+  await expect
+    .poll(() =>
+      page.evaluate(() => {
+        const row = Array.from(
+          document.querySelectorAll<HTMLElement>("[data-message-id]"),
+        ).at(-1);
+        const composer = document.querySelector<HTMLElement>(
+          '[data-testid="message-composer"]',
+        );
+        if (!row || !composer) return Number.NEGATIVE_INFINITY;
+        return (
+          composer.getBoundingClientRect().top -
+          row.getBoundingClientRect().bottom
+        );
+      }),
+    )
+    .toBeGreaterThanOrEqual(0);
+});
+
+test("supports multiline drafts with Ctrl+Enter and sends with Enter", async ({
+  page,
+}) => {
+  const firstLine = `Shortcut smoke line one ${Date.now()}`;
+  const restOfLines = [
+    "Shortcut smoke line two",
+    "Shortcut smoke line three",
+    "Shortcut smoke line four",
+    "Shortcut smoke line five",
+  ];
+  const input = page.getByTestId("message-input");
+
+  await page.goto("/");
+  await page.getByTestId("channel-general").click();
+  await expect(page.getByTestId("chat-title")).toHaveText("general");
+  await expect(
+    page.getByRole("button", { name: "Send message" }),
+  ).toBeVisible();
+  const initialInputHeight = await input.evaluate(
+    (element) => (element as HTMLElement).clientHeight,
+  );
+  expect(initialInputHeight).toBeLessThan(40);
+  await input.fill(firstLine);
+  for (const line of restOfLines) {
+    await input.press("Shift+Enter");
+    await input.pressSequentially(line);
+  }
+  for (const line of [firstLine, ...restOfLines]) {
+    await expect(input).toContainText(line);
+  }
+  const expandedInputHeight = await input.evaluate(
+    (element) => (element as HTMLElement).clientHeight,
+  );
+  expect(expandedInputHeight).toBeLessThanOrEqual(130);
+  await expect(page.getByTestId("message-timeline")).not.toContainText(
+    firstLine,
+  );
+  await input.press("Enter");
+
+  await expect(page.getByTestId("message-timeline")).toContainText(firstLine);
+  await expect(page.getByTestId("message-timeline")).toContainText(
+    restOfLines[restOfLines.length - 1],
+  );
+});
+
+test("does not shift the timeline when the composer grows", async ({
+  page,
+}) => {
+  const input = page.getByTestId("message-input");
+  const prefix = `Composer growth ${Date.now()}`;
+
+  await page.goto("/");
+  await page.getByTestId("channel-general").click();
+  await expect(page.getByTestId("chat-title")).toHaveText("general");
+
+  await ensureTimelineScrollable(page, prefix);
+  await page.waitForTimeout(400);
+  await page.getByTestId("message-timeline").evaluate((element) => {
+    const timeline = element as HTMLDivElement;
+    // The raw position assignment sets up detached history, while wheel is the
+    // same ownership signal a real reader produces before composer reflow.
+    timeline.dispatchEvent(new WheelEvent("wheel", { deltaY: -100 }));
+    timeline.scrollTop = 0;
+    timeline.dispatchEvent(new Event("scroll"));
+  });
+  await expect
+    .poll(async () => (await getTimelineMetrics(page)).distanceFromBottom)
+    .toBeGreaterThan(160);
+  const before = await getTimelineMetrics(page);
+
+  await input.fill("Composer growth line one");
+  await input.press("Shift+Enter");
+  await input.pressSequentially("Composer growth line two");
+  await input.press("Shift+Enter");
+  await input.pressSequentially("Composer growth line three");
+  await input.press("Shift+Enter");
+  await input.pressSequentially("Composer growth line four");
+
+  await page.waitForTimeout(1200);
+
+  const after = await getTimelineMetrics(page);
+  expect(after.clientHeight).toBeLessThanOrEqual(before.clientHeight);
+  expect(Math.abs(after.scrollTop - before.scrollTop)).toBeLessThanOrEqual(2);
+  expect(after.distanceFromBottom).toBeGreaterThan(160);
+});