feat(web): 移除首启内测声明，遥测保持默认关闭

packages/client/ui-settings-general/tests/apply.client.spec.ts

@@ -1,18 +1,15 @@
-/** Ownerless-copy registrations: the six seats, dictionaries, thunked labels, and HMR recovery. */
+/** Ownerless-copy registrations: the five seats, dictionaries, thunked labels, and HMR recovery. */
 import { Context } from '@deepseek-ai/cordis'
 import { describe, expect, it, vi } from 'vitest'
 import { resolveSlotLabel } from '@deepseek-ai/dsh-client-ui-slots'
 import { SlotRegistry } from '@deepseek-ai/dsh-client-runtime/client'
 import { LocaleRuntime } from '@deepseek-ai/dsh-client-locale/client'
-import { TestRemote, usePinnedBrowserLanguages } from '@deepseek-ai/dsh-client-test-runtime'
+import { usePinnedBrowserLanguages } from '@deepseek-ai/dsh-client-test-runtime'
 import { apply, inject } from '@deepseek-ai/dsh-client-ui-settings-general/client'
 import { CloseLabel, HeaderContent, TriggerContent } from '../src/client/chrome.tsx'
 import { GeneralSection } from '../src/client/GeneralSection.tsx'
 import { SettingsDocumentAction } from '../src/client/SettingsDocumentAction.tsx'
 import type { SettingsDocumentActionInjected } from '../src/client/SettingsDocumentAction.tsx'
-import { WelcomeNotice } from '../src/client/WelcomeNotice.tsx'
-import type { WelcomeNoticeInjected } from '../src/client/WelcomeNotice.tsx'
-import { WELCOME_NOTICE_SETTINGS_NAMESPACE } from '../src/onboarding-copy.ts'
 
 // The service reads its initial locale from the browser; these specs assert
 // the shipped Chinese copy, so they state the browser they assume.
@@ -25,7 +22,6 @@ const SEATS = [
   ['settings.action', SettingsDocumentAction],
   ['settings.close', CloseLabel],
   ['settings.section', GeneralSection],
-  ['settings.onboarding', WelcomeNotice],
 ] as const
 
 async function bench(isLoopback = true) {
@@ -33,9 +29,6 @@ async function bench(isLoopback = true) {
   await ctx.plugin(SlotRegistry).await()
   const locale = new LocaleRuntime(ctx)
   ctx.provide('locale', locale)
-  // The plugins inject `remote`; forwarded events reach them through the
-  // same `$dispatch` handoff the connection sink makes.
-  new TestRemote(ctx)
   const settingsDescribe = vi.fn(() => Promise.resolve({
     rpcId: 'settings-general' as never,
     result: {
@@ -43,14 +36,7 @@ async function bench(isLoopback = true) {
       value: {
         writable: true,
         hasDocument: true,
-        namespaces: [{
-          ns: WELCOME_NOTICE_SETTINGS_NAMESPACE,
-          schema: {},
-          value: {},
-          applies: 'live' as const,
-          secrets: [],
-          revision: 0,
-        }],
+        namespaces: [],
       },
     },
   }))
@@ -89,10 +75,10 @@ function generalEntry(slots: SlotRegistry) {
 
 describe('ui-settings-general apply', () => {
   it('declares the services it uses', () => {
-    expect(inject).toEqual(['slots', 'locale', 'connection', 'remote'])
+    expect(inject).toEqual(['slots', 'locale', 'connection'])
   })
 
-  it('fills all six seats for declarations before or after apply', async () => {
+  it('fills all five seats for declarations before or after apply', async () => {
     const before = await bench()
     declare(before.slots)
     await before.ctx.plugin({ inject: [...inject], apply }).await()
@@ -105,8 +91,9 @@ describe('ui-settings-general apply', () => {
     expect(resolveSlotLabel(entry.options.label)).toBe('通用设置')
     expect(before.slots.spec('settings.general.item')).toEqual({ kind: 'list', scope: 'root' })
     expect(before.slots.entries('settings.general.item')).toEqual([])
-    const welcome = before.slots.entries('settings.onboarding')[0]!
-    expect(welcome.options).toMatchObject({ id: 'welcome-notice', order: -100 })
+    // The onboarding hole stays declared for feature-owned steps; this plugin
+    // no longer seats one.
+    expect(before.slots.entries('settings.onboarding')).toEqual([])
     const action = before.slots.entries('settings.action')[0]!
     const actionInjected = (action.inject as unknown as () => SettingsDocumentActionInjected)()
     expect(actionInjected.controller.store.getSnapshot().status).toBe('idle')
@@ -162,22 +149,6 @@ describe('ui-settings-general apply', () => {
     expect(resolveSlotLabel(generalEntry(b.slots)!.options.label)).toBe('通用设置')
   })
 
-  it('refreshes loaded welcome state only for its settings namespace or a reconnect', async () => {
-    const b = await bench()
-    declare(b.slots)
-    await b.ctx.plugin({ inject: [...inject], apply }).await()
-    const entry = b.slots.entries('settings.onboarding')[0]!
-    const { controller } = (entry.inject as unknown as () => WelcomeNoticeInjected)()
-    await controller.load()
-    expect(b.settingsDescribe).toHaveBeenCalledOnce()
-    b.ctx.remote.$dispatch('settings/document-updated', ['unrelated', 1])
-    expect(b.settingsDescribe).toHaveBeenCalledOnce()
-    b.ctx.remote.$dispatch('settings/document-updated', [WELCOME_NOTICE_SETTINGS_NAMESPACE, 1])
-    await vi.waitFor(() => { expect(b.settingsDescribe).toHaveBeenCalledTimes(2) })
-    b.ctx.emit('connection/reset')
-    await vi.waitFor(() => { expect(b.settingsDescribe).toHaveBeenCalledTimes(3) })
-  })
-
   it('refreshes loaded document availability on reconnect without reading it eagerly', async () => {
     const b = await bench()
     declare(b.slots)
@@ -192,19 +163,13 @@ describe('ui-settings-general apply', () => {
     await vi.waitFor(() => { expect(b.settingsDescribe).toHaveBeenCalledTimes(2) })
   })
 
-  it('keeps remote welcome acknowledgement process-local', async () => {
+  it('withholds the loopback-only document action off-loopback', async () => {
     const b = await bench(false)
     declare(b.slots)
     const fiber = b.ctx.plugin({ inject: [...inject], apply })
     await fiber.await()
-    const entry = b.slots.entries('settings.onboarding')[0]!
-    const { controller } = (entry.inject as unknown as () => WelcomeNoticeInjected)()
-
-    await controller.load()
-    await expect(controller.acknowledge()).resolves.toBe(true)
-    expect(controller.store.getSnapshot()).toMatchObject({ status: 'ready', acknowledged: true })
-    expect(b.settingsDescribe).not.toHaveBeenCalled()
     expect(b.slots.entries('settings.action')).toEqual([])
+    expect(b.settingsDescribe).not.toHaveBeenCalled()
     await fiber.dispose()
     for (const [name] of SEATS) expect(b.slots.entries(name)).toEqual([])
   })

packages/client/ui-settings-general/tests/host.client.spec.ts

@@ -2,7 +2,9 @@ import { Context } from '@deepseek-ai/cordis'
 import { describe, expect, it } from 'vitest'
 import { SettingsProvider, settingsNamespace, type SettingsNamespace } from '@deepseek-ai/dsh-settings'
 import { apply } from '../src/index.ts'
-import { WELCOME_NOTICE_SETTINGS_NAMESPACE } from '../src/onboarding-copy.ts'
+
+/** Mirrors the module-local namespace id in src/index.ts. */
+const ONBOARDING_SETTINGS_NAMESPACE = 'ui-onboarding'
 
 class MemorySettings extends SettingsProvider {
   readonly writable = true
@@ -19,11 +21,11 @@ describe('ui-settings-general host', () => {
     const fiber = ctx.plugin({ apply })
     await fiber.await()
     expect(ctx.settings.describe().map(row => row.ns)).toContain(
-      settingsNamespace(WELCOME_NOTICE_SETTINGS_NAMESPACE),
+      settingsNamespace(ONBOARDING_SETTINGS_NAMESPACE),
     )
     await fiber.dispose()
     expect(ctx.settings.describe().map(row => row.ns)).not.toContain(
-      settingsNamespace(WELCOME_NOTICE_SETTINGS_NAMESPACE),
+      settingsNamespace(ONBOARDING_SETTINGS_NAMESPACE),
     )
   })
 })

packages/client/ui-settings-general/tests/shell.client.spec.ts

@@ -49,7 +49,7 @@ const CHILD_SPECS = {
 
 describe('ui-settings apply', () => {
   it('declares only the slot registry (a pure composition face, no locale)', () => {
-    expect(inject).toEqual(['slots', 'locale', 'connection', 'remote'])
+    expect(inject).toEqual(['slots', 'locale', 'connection'])
   })
 
   it('registers the shell and declares every child slot, before or after the declaration', async () => {
@@ -110,8 +110,6 @@ describe('ui-settings apply', () => {
     b.slots.register({ name: 'settings.onboarding', id: 'default-order' } as never, () => null)
     const steps = onboardingSteps.getSnapshot()
     expect(steps).toEqual([
-      // This package's own onboarding page, registered by the same apply.
-      { id: 'welcome-notice', order: -100 },
       { id: 'welcome', order: -100 },
       { id: 'credential', order: 0 },
       { id: 'default-order', order: 0 },

packages/client/ui-settings-general/tests/welcome-notice.client.spec.tsx

@@ -1,106 +0,0 @@
-// @vitest-environment jsdom
-import { act, cleanup, fireEvent, render, screen } from '@testing-library/react'
-import { afterEach, describe, expect, it, vi } from 'vitest'
-import { bindSnapshotSelector } from '@deepseek-ai/dsh-client-web-react'
-import { WelcomeNotice } from '../src/client/WelcomeNotice.tsx'
-import type { WelcomeNoticeProps } from '../src/client/WelcomeNotice.tsx'
-import { WelcomeNoticeStore } from '../src/client/welcome-store.ts'
-import { zh } from '../src/client/locales.ts'
-import {
-  WELCOME_NOTICE_ACK_FIELD, WELCOME_NOTICE_COPY, WELCOME_NOTICE_SETTINGS_NAMESPACE,
-  WELCOME_NOTICE_VERSION,
-} from '../src/onboarding-copy.ts'
-
-afterEach(cleanup)
-
-function response<T>(value: T) {
-  return { rpcId: 'welcome-rpc' as never, result: { ok: true as const, value } }
-}
-
-function mount(version?: string, mutateImpl: () => Promise<unknown> = () => Promise.resolve(response({}))) {
-  const mutate = vi.fn(mutateImpl)
-  const api = {
-    settings: {
-      describe: () => Promise.resolve(response({
-        writable: true,
-        hasDocument: false,
-        namespaces: [{
-          ns: WELCOME_NOTICE_SETTINGS_NAMESPACE,
-          schema: {},
-          value: version === undefined ? {} : { [WELCOME_NOTICE_ACK_FIELD]: version },
-          applies: 'live' as const,
-          secrets: [],
-          revision: 0,
-        }],
-      })),
-      mutate,
-    },
-  }
-  const controller = new WelcomeNoticeStore(api as never)
-  const complete = vi.fn()
-  const unusedHook = (() => { throw new Error('unused standard hook') }) as never
-  const props: WelcomeNoticeProps = {
-    stepId: 'welcome-notice',
-    complete,
-    openSection: vi.fn(),
-    useSessions: unusedHook,
-    useWorkspaces: unusedHook,
-    controller,
-    useSnapshot: bindSnapshotSelector(controller.store),
-    t: key => key in zh ? zh[key as keyof typeof zh] : key,
-  }
-  return { ...render(<WelcomeNotice {...props} />), complete, controller, mutate }
-}
-
-describe('WelcomeNotice', () => {
-  it('uses the same Chinese owner copy in both GUI locales', () => {
-    expect(WELCOME_NOTICE_COPY.en).toEqual(WELCOME_NOTICE_COPY.zh)
-  })
-
-  it('renders the owner copy with one primary action and no dismissal control', async () => {
-    const h = mount()
-    const page = await screen.findByRole('region', { name: WELCOME_NOTICE_COPY.zh.title })
-    expect(screen.getByText(WELCOME_NOTICE_COPY.zh.title)).toBeTruthy()
-    for (const text of WELCOME_NOTICE_COPY.zh.paragraphs) expect(page.textContent).toContain(text)
-    expect(page.textContent?.match(/感谢您愿意拨冗试用 DeepSeek Harness/g) ?? []).toHaveLength(1)
-    const buttons = page.querySelectorAll('button')
-    expect(buttons).toHaveLength(1)
-    expect(screen.getByRole('button', { name: WELCOME_NOTICE_COPY.zh.continueLabel })).toBeTruthy()
-    expect(document.activeElement).toBe(screen.getByRole('heading', { name: WELCOME_NOTICE_COPY.zh.title }))
-    fireEvent.keyDown(document, { key: 'Escape' })
-    expect(h.complete).not.toHaveBeenCalled()
-    expect(screen.getByRole('region')).toBeTruthy()
-  })
-
-  it('completes only after the acknowledgement write commits', async () => {
-    const h = mount()
-    await screen.findByRole('region')
-    fireEvent.click(screen.getByRole('button', { name: WELCOME_NOTICE_COPY.zh.continueLabel }))
-    await act(async () => { await Promise.resolve() })
-    expect(h.mutate).toHaveBeenCalledOnce()
-    expect(h.complete).toHaveBeenCalledOnce()
-  })
-
-  it('skips itself when this exact version was already acknowledged', async () => {
-    const h = mount(WELCOME_NOTICE_VERSION)
-    await act(async () => { await h.controller.load() })
-    expect(screen.queryByRole('region')).toBeNull()
-    expect(h.complete).toHaveBeenCalledOnce()
-  })
-
-  it('keeps the sole action disabled while saving and reports a refused write', async () => {
-    let resolveWrite!: (value: unknown) => void
-    const write = new Promise<unknown>((resolve) => { resolveWrite = resolve })
-    const h = mount(undefined, () => write)
-    await screen.findByRole('region')
-    const action = screen.getByRole<HTMLButtonElement>('button', { name: WELCOME_NOTICE_COPY.zh.continueLabel })
-    fireEvent.click(action)
-    expect(action.disabled).toBe(true)
-    resolveWrite({
-      rpcId: 'welcome-refused' as never,
-      result: { ok: false, error: { code: 'settings-rejected', message: 'read only', details: { ns: WELCOME_NOTICE_SETTINGS_NAMESPACE } } },
-    })
-    expect((await screen.findByRole('alert')).textContent).toBe('暂时无法保存确认状态，请重试。')
-    expect(h.complete).not.toHaveBeenCalled()
-  })
-})

packages/client/ui-settings-general/tests/welcome-store.client.spec.ts

@@ -1,184 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-import type { RpcResponse } from '@deepseek-ai/dsh-api-remotes/client'
-import { WelcomeNoticeStore } from '../src/client/welcome-store.ts'
-import { refreshWelcomeIfLoaded } from '../src/client/welcome-store.ts'
-import {
-  WELCOME_NOTICE_ACK_FIELD, WELCOME_NOTICE_SETTINGS_NAMESPACE, WELCOME_NOTICE_VERSION,
-} from '../src/onboarding-copy.ts'
-
-let rpc = 0
-function ok<T>(value: T): RpcResponse<T> {
-  return { rpcId: `welcome-${rpc++}` as never, result: { ok: true, value } }
-}
-
-function namespace(version?: string) {
-  return {
-    ns: WELCOME_NOTICE_SETTINGS_NAMESPACE,
-    schema: {},
-    value: version === undefined ? {} : { [WELCOME_NOTICE_ACK_FIELD]: version },
-    applies: 'live' as const,
-    secrets: [],
-    revision: 0,
-  }
-}
-
-function deferred<T>() {
-  let resolve!: (value: T) => void
-  let reject!: (reason: unknown) => void
-  const promise = new Promise<T>((res, rej) => { resolve = res; reject = rej })
-  return { promise, resolve, reject }
-}
-
-describe('WelcomeNoticeStore', () => {
-  it('acknowledges in memory without calling loopback-only settings APIs', async () => {
-    const describe = vi.fn()
-    const mutate = vi.fn()
-    const controller = new WelcomeNoticeStore({ settings: { describe, mutate } } as never, 'memory')
-
-    await controller.load()
-    expect(controller.store.getSnapshot()).toEqual({ status: 'ready', acknowledged: false, error: null })
-    await expect(controller.acknowledge()).resolves.toBe(true)
-    expect(controller.store.getSnapshot()).toEqual({ status: 'ready', acknowledged: true, error: null })
-    await controller.load()
-    expect(controller.store.getSnapshot()).toEqual({ status: 'ready', acknowledged: true, error: null })
-    expect(describe).not.toHaveBeenCalled()
-    expect(mutate).not.toHaveBeenCalled()
-  })
-
-  it('acknowledges only the exact current copy version', async () => {
-    for (const [version, acknowledged] of [
-      [undefined, false],
-      ['older-copy', false],
-      [WELCOME_NOTICE_VERSION, true],
-    ] as const) {
-      const api = {
-        settings: {
-          describe: vi.fn(() => Promise.resolve(ok({ writable: true, hasDocument: false, namespaces: [namespace(version)] }))),
-        },
-      }
-      const controller = new WelcomeNoticeStore(api as never)
-      await controller.load()
-      expect(controller.store.getSnapshot()).toMatchObject({ status: 'ready', acknowledged })
-    }
-  })
-
-  it('persists the owner version through one idempotent path mutation', async () => {
-    const mutate = vi.fn(() => Promise.resolve(ok(namespace(WELCOME_NOTICE_VERSION))))
-    const controller = new WelcomeNoticeStore({ settings: { mutate } } as never)
-    await expect(controller.acknowledge()).resolves.toBe(true)
-    expect(mutate).toHaveBeenCalledWith({
-      ns: WELCOME_NOTICE_SETTINGS_NAMESPACE,
-      ops: [{ op: 'set', path: [WELCOME_NOTICE_ACK_FIELD], value: WELCOME_NOTICE_VERSION }],
-    })
-    expect(controller.store.getSnapshot()).toMatchObject({ status: 'ready', acknowledged: true })
-  })
-
-  it('keeps the notice pending when loading or persistence fails', async () => {
-    const load = new WelcomeNoticeStore({
-      settings: { describe: () => Promise.reject(new Error('offline')) },
-    } as never)
-    await load.load()
-    expect(load.store.getSnapshot()).toEqual({ status: 'error', acknowledged: false, error: 'offline' })
-
-    const save = new WelcomeNoticeStore({
-      settings: { mutate: () => Promise.reject(new Error('disk full')) },
-    } as never)
-    await expect(save.acknowledge()).resolves.toBe(false)
-    expect(save.store.getSnapshot()).toEqual({ status: 'error', acknowledged: false, error: 'disk full' })
-
-    const nonError = new WelcomeNoticeStore({
-      // Durable/wire failures are unknown; exercise containment of a non-Error rejection.
-      // oxlint-disable-next-line typescript/prefer-promise-reject-errors
-      settings: { describe: () => Promise.reject('offline string') },
-    } as never)
-    await nonError.load()
-    expect(nonError.store.getSnapshot().error).toBe('offline string')
-  })
-
-  it('reports business failures, missing namespaces, and malformed durable values', async () => {
-    for (const describe of [
-      () => Promise.resolve({
-        rpcId: 'failed' as never,
-        result: { ok: false as const, error: { code: 'internal' as const, message: 'denied', details: {} } },
-      }),
-      () => Promise.resolve(ok({ writable: true, hasDocument: false, namespaces: [] })),
-    ]) {
-      const controller = new WelcomeNoticeStore({ settings: { describe } } as never)
-      await controller.load()
-      expect(controller.store.getSnapshot().status).toBe('error')
-    }
-
-    for (const value of [null, 42, { [WELCOME_NOTICE_ACK_FIELD]: 42 }]) {
-      const controller = new WelcomeNoticeStore({
-        settings: { describe: () => Promise.resolve(ok({
-          writable: true,
-          hasDocument: false,
-          namespaces: [{ ...namespace(), value }],
-        })) },
-      } as never)
-      await controller.load()
-      expect(controller.store.getSnapshot()).toMatchObject({ status: 'ready', acknowledged: false })
-    }
-
-    const save = new WelcomeNoticeStore({
-      settings: { mutate: () => Promise.resolve({
-        rpcId: 'failed-save' as never,
-        result: { ok: false, error: { code: 'settings-rejected', message: 'denied', details: { ns: WELCOME_NOTICE_SETTINGS_NAMESPACE } } },
-      }) },
-    } as never)
-    await expect(save.acknowledge()).resolves.toBe(false)
-    expect(save.store.getSnapshot().error).toBe('denied')
-  })
-
-  it('lets the latest load win over stale success and failure', async () => {
-    const first = deferred<ReturnType<typeof ok>>()
-    const describe = vi.fn()
-      .mockImplementationOnce(() => first.promise)
-      .mockImplementationOnce(() => Promise.resolve(ok({ writable: true, hasDocument: false, namespaces: [namespace()] })))
-    const controller = new WelcomeNoticeStore({ settings: { describe } } as never)
-    const stale = controller.load()
-    await controller.load()
-    first.resolve(ok({ writable: true, hasDocument: false, namespaces: [namespace(WELCOME_NOTICE_VERSION)] }))
-    await stale
-    expect(controller.store.getSnapshot().acknowledged).toBe(false)
-
-    const failed = deferred<ReturnType<typeof ok>>()
-    describe
-      .mockImplementationOnce(() => failed.promise)
-      .mockImplementationOnce(() => Promise.resolve(ok({
-        writable: true, hasDocument: false, namespaces: [namespace(WELCOME_NOTICE_VERSION)],
-      })))
-    const staleFailure = controller.load()
-    await controller.load()
-    failed.reject('stale failure')
-    await staleFailure
-    expect(controller.store.getSnapshot()).toMatchObject({ status: 'ready', acknowledged: true, error: null })
-  })
-
-  it('contains stale acknowledgement settlements and refreshes only a loaded store', async () => {
-    const write = deferred<ReturnType<typeof ok>>()
-    const describe = vi.fn(() => Promise.resolve(ok({ writable: true, hasDocument: false, namespaces: [namespace()] })))
-    const controller = new WelcomeNoticeStore({
-      settings: { mutate: () => write.promise, describe },
-    } as never)
-    refreshWelcomeIfLoaded(controller)
-    expect(describe).not.toHaveBeenCalled()
-    const staleWrite = controller.acknowledge()
-    await controller.load()
-    write.resolve(ok(namespace(WELCOME_NOTICE_VERSION)))
-    await expect(staleWrite).resolves.toBe(true)
-    expect(controller.store.getSnapshot().acknowledged).toBe(false)
-    refreshWelcomeIfLoaded(controller)
-    await vi.waitFor(() => { expect(describe).toHaveBeenCalledTimes(2) })
-
-    const failedWrite = deferred<ReturnType<typeof ok>>()
-    const staleFailure = new WelcomeNoticeStore({
-      settings: { mutate: () => failedWrite.promise, describe },
-    } as never)
-    const pending = staleFailure.acknowledge()
-    await staleFailure.load()
-    failedWrite.reject('late failure')
-    await expect(pending).resolves.toBe(false)
-    expect(staleFailure.store.getSnapshot().status).toBe('ready')
-  })
-})