@sophiacyl/dsh-plugin-waves 0.0.0-stage → 0.1.0-beta.2

package/tests/compat.test.js

@@ -0,0 +1,181 @@
+import assert from 'node:assert/strict'
+import { readFile } from 'node:fs/promises'
+import { test } from 'node:test'
+import vm from 'node:vm'
+import { readAttachments } from '../lib/host/attachments.js'
+import { runSlashCommand } from '../lib/host/command.js'
+import { makeResultStore } from '../lib/host/results.js'
+
+const signal = new AbortController().signal
+const image = { type: 'image', attachment: { attachmentId: 'image-id' } }
+const file = { type: 'file', attachment: { attachmentId: 'file-id', name: 'records.json' } }
+const ctx = { get: () => ({
+  async readImage(ref, receivedSignal) {
+    assert.equal(ref, image.attachment)
+    assert.equal(receivedSignal, signal)
+    return { data: Buffer.from('image') }
+  },
+  async *readFileStream(ref, receivedSignal) {
+    assert.equal(ref, file.attachment)
+    assert.equal(receivedSignal, signal)
+    yield Buffer.from('{')
+    yield Buffer.from('}')
+  },
+}) }
+
+test('DSH 0.2 attachments reach the service as images and one named file', async () => {
+  const results = makeResultStore()
+  let body
+  const result = await runSlashCommand({ async call(path, options) {
+    assert.equal(path, '/api/chat')
+    assert.equal(options.signal, signal)
+    body = options.body
+    return { ok: true, summary: '评分完成', segments: [{ type: 'html', url: '/api/media/panel.html' }] }
+  } }, results, { rawInput: '-p 评分', agent: { id: 'session-id' }, commandId: 'command-id', signal,
+    attachments: [image, file] }, (blocks, signal) => readAttachments(ctx, blocks, signal))
+  assert.equal(result.kind, 'success')
+  assert.deepEqual(body, { command: '评分', scene: 'direct', session_id: 'session-id',
+    images: ['base64://aW1hZ2U='], file_name: 'records.json', file_data: 'e30=' })
+  assert.equal(results.get('command-id').segments[0].type, 'html')
+})
+
+test('attachment read failures refuse dispatch and preserve the command failure', async () => {
+  const failure = new Error('图片读取失败')
+  let called = false
+  const result = await runSlashCommand({ call() { called = true } }, makeResultStore(), {
+    rawInput: '评分', signal, attachments: [image],
+  }, () => { throw failure })
+  assert.equal(called, false)
+  assert.equal(result.kind, 'error')
+  assert.match(result.text, /图片读取失败/)
+  await assert.rejects(readAttachments({ get: () => null }, [image], signal), /附件服务不可用/)
+  await assert.rejects(readAttachments(ctx, [file, file], signal), /一次只接受一个文件/)
+})
+
+test('no attachments and canceled commands keep their original semantics', async () => {
+  assert.deepEqual(await readAttachments({ get: () => null }, [], signal), { images: [] })
+  const controller = new AbortController()
+  controller.abort()
+  const result = await runSlashCommand({ call() { throw new Error('aborted') } }, makeResultStore(), {
+    rawInput: '查询', signal: controller.signal,
+  })
+  assert.equal(result.kind, 'error')
+  assert.match(result.text, /已取消/)
+})
+
+async function clientFixture(execution, { deferred = [] } = {}) {
+  let plugin, source
+  const slots = new Map()
+  const pending = new Map()
+  const requests = []
+  const react = {
+    createElement: (type, props, ...children) => ({ type, props, children }),
+    useState: (initial) => [typeof initial === 'function' ? initial() : initial, () => {}],
+    useEffect: () => {}, useRef: (value) => ({ current: value }), useCallback: (fn) => fn,
+  }
+  const sandbox = {
+    window: { __ModuleLoader__: { load: ({ factory }) => { plugin = factory(() => react) } } },
+    document: { body: {}, head: { appendChild() {} }, getElementById: () => ({}), querySelectorAll: () => [] },
+    MutationObserver: class { observe() {} },
+    localStorage: { getItem: (key) => key === 'ww-slash-prefixes' ? '["/ww","/xw"]' : null, setItem() {} },
+    fetch: async (path, options) => {
+      requests.push({ path, options })
+      return { ok: true, json: async () => ({ ok: true, prefixes: ['ww', 'xw'], segments: [] }) }
+    },
+    setTimeout, clearTimeout,
+  }
+  vm.runInNewContext(await readFile(new URL('../lib/client.js', import.meta.url), 'utf8'), sandbox)
+  const ctx = {
+    effect: (setup) => setup(),
+    on: () => () => {},
+    inject: (dependencies, setup) => setup(ctx),
+    remote: { commands: { execute: execution } },
+    inputTriggers: { registerSource: (registered) => { source = registered } },
+    slots: {
+      inject: (name, setup) => deferred.includes(name) ? pending.set(name, setup) : setup(),
+      register: (spec, view) => {
+        const key = spec.name + ":" + (spec.key || spec.id)
+        slots.set(key, view)
+        return () => slots.delete(key)
+      },
+    },
+  }
+  plugin.apply(ctx)
+  return { source, slots, requests, declare: (name) => pending.get(name)() }
+}
+
+test('compact slash claims follow the DSH 0.2 contract and forward attachments once', async () => {
+  const calls = []
+  const { source } = await clientFixture(async (...args) => {
+    calls.push(args)
+    return { ok: true, value: { result: { kind: 'success' } } }
+  })
+  assert.equal(await source.matchEnter({ sessionId: 'session' }, '/ww 查询'), undefined)
+  const { claim } = await source.matchEnter({ sessionId: 'session' }, '/xw评分')
+  assert.equal(claim.name, 'xw')
+  assert.equal(claim.token, '/xw ')
+  assert.equal(claim.attachments, true)
+  const images = [{ type: 'image', data: 'image-base64', mediaType: 'image/png' }]
+  assert.equal((await claim.submit('', {}, images)).kind, 'success')
+  assert.deepEqual(calls, [['session', '/ww 评分', images]])
+})
+
+test('compact slash failures return error so the composer retains attachments', async () => {
+  const { source } = await clientFixture(async () => ({ ok: true, value: { result: { kind: 'error', text: '评分失败' } } }))
+  const { claim } = await source.matchEnter({ sessionId: 'session' }, '/ww评分')
+  assert.equal((await claim.submit('', {}, [])).text, '评分失败')
+})
+
+test('rc.7 arity fallback only retries argument validation without attachments', async () => {
+  const calls = []
+  const { source } = await clientFixture(async (...args) => {
+    calls.push(args)
+    if (args.length === 3) throw new Error('expected 2 business arguments')
+    return { ok: true, value: { result: { kind: 'success' } } }
+  })
+  const { claim } = await source.matchEnter({ sessionId: 'session' }, '/ww查询')
+  assert.equal((await claim.submit('', {}, [])).kind, 'success')
+  assert.deepEqual(calls.map(args => args.length), [3, 2])
+  calls.length = 0
+  await assert.rejects(claim.submit('', {}, [image]), /expected 2 business arguments/)
+  assert.equal(calls.length, 1)
+})
+
+test('settled tool cards use current metadata and the real session for follow-up commands', async () => {
+  const { slots, requests } = await clientFixture()
+  const view = slots.get('tool.call.toolview:waves')
+  const tree = view({ sessionId: 'session', callId: 'tool-id', phase: 'result', block: {
+    kind: 'tool-result', call: { name: 'waves', argsRaw: '{"command":"ww查询"}' },
+    meta: { segments: [{ type: 'text', text: '查询结果' }] },
+  } })
+  const find = (node) => node && typeof node === 'object' && (
+    node.props?.seg ? node : node.children?.flat().map(find).find(value => value && typeof value === 'object')
+  )
+  const segment = find(tree)
+  assert.equal(segment.props.seg.text, '查询结果')
+  await segment.props.onCommand('ww椿面板')
+  const request = requests.find(({ path }) => path === '/waves-api/api/chat')
+  assert.equal(JSON.parse(request.options.body).session_id, 'session')
+})
+
+test('service env drops bracketed no_proxy entries that httpx rejects', async () => {
+  const { serviceEnv } = await import('../lib/host/service.js')
+  const env = serviceEnv(9777, { no_proxy: 'localhost,127.0.0.1,::1,[::1]', NO_PROXY: '[::1]', HTTP_PROXY: 'http://127.0.0.1:1' })
+  assert.equal(env.no_proxy, 'localhost,127.0.0.1,::1')
+  assert.equal(env.NO_PROXY, '')
+  assert.equal(env.HTTP_PROXY, 'http://127.0.0.1:1')
+  assert.equal(env.ROVER_PORT, '9777')
+  assert.equal(serviceEnv(1, {}).no_proxy, undefined)
+})
+
+test('config page lives on the plugins page and falls back to settings only without it', async () => {
+  const { slots } = await clientFixture()
+  assert.ok(slots.has('plugins.bundle.config:@sophiacyl/dsh-plugin-waves'))
+  assert.ok(!slots.has('settings.section:waves'))
+
+  const legacy = await clientFixture(undefined, { deferred: ['plugins.bundle.config'] })
+  assert.ok(legacy.slots.has('settings.section:waves'))
+  legacy.declare('plugins.bundle.config')
+  assert.ok(legacy.slots.has('plugins.bundle.config:@sophiacyl/dsh-plugin-waves'))
+  assert.ok(!legacy.slots.has('settings.section:waves'))
+})

package/tests/imagebridge.test.js

@@ -0,0 +1,58 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import { registerImageBridge, takeImages } from '../lib/host/imagebridge.js'
+
+function fixture() {
+  const listeners = new Map()
+  const disposers = []
+  const injected = []
+  const resolveModelInfo = async () => ({ inputModalities: ['text'] })
+  const ctx = {
+    llm: { resolveModelInfo },
+    inject(deps, callback) { injected.push(...deps); callback(ctx) },
+    on(event, fn) { listeners.set(event, fn) },
+    effect(fn) { disposers.push(fn()) },
+  }
+  registerImageBridge(ctx)
+  return { ctx, listeners, disposers, injected, resolveModelInfo }
+}
+
+const ref = Object.freeze({ attachmentId: 'test-image' })
+const image = Object.freeze({ type: 'image', attachment: ref })
+const message = Object.freeze({ role: 'user', source: { kind: 'user' }, content: Object.freeze([image, Object.freeze({ type: 'text', text: '普通聊天截图' })]) })
+
+test('image observer preserves host decision and exact user image content', async () => {
+  const { ctx, listeners, injected, resolveModelInfo } = fixture()
+  const decision = Object.freeze({ kind: 'enter', messages: Object.freeze([message]) })
+  const value = await listeners.get('agent/pre-step')({ agent: { id: 'preserve' } }, async () => decision)
+  assert.equal(value, decision)
+  assert.equal(value.messages[0], message)
+  assert.equal(value.messages[0].content[0], image)
+  assert.equal(value.messages[0].content.length, 2)
+  assert.equal(ctx.llm.resolveModelInfo, resolveModelInfo)
+  assert.deepEqual(injected, ['agents'])
+  assert.deepEqual(takeImages('preserve'), [ref])
+  assert.deepEqual(takeImages('preserve'), [])
+})
+
+test('images are isolated by session and removed for a later text-only step', async () => {
+  const { listeners } = fixture()
+  const step = listeners.get('agent/pre-step')
+  await step({ agent: { id: 'a' } }, async () => ({ kind: 'enter', messages: [message] }))
+  assert.deepEqual(takeImages('b'), [])
+  await step({ agent: { id: 'a' } }, async () => ({ kind: 'enter', messages: [{ role: 'user', content: [{ type: 'text', text: '下一条' }] }] }))
+  assert.deepEqual(takeImages('a'), [])
+})
+
+test('rejected steps and disposal clear pending images without altering host results', async () => {
+  const { listeners, disposers } = fixture()
+  const step = listeners.get('agent/pre-step')
+  await step({ agent: { id: 'reject' } }, async () => ({ kind: 'enter', messages: [message] }))
+  const rejected = { kind: 'reject' }
+  assert.equal(await step({ agent: { id: 'reject' } }, async () => rejected), rejected)
+  assert.deepEqual(takeImages('reject'), [])
+  await step({ agent: { id: 'dispose' } }, async () => ({ kind: 'enter', messages: [message] }))
+  listeners.get('agent/disposed')({ agent: { id: 'dispose' } })
+  assert.deepEqual(takeImages('dispose'), [])
+  for (const dispose of disposers) dispose()
+})

package/tests/media.test.js

@@ -0,0 +1,68 @@
+import assert from 'node:assert/strict'
+import { mkdtemp, mkdir, writeFile, symlink, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { test } from 'node:test'
+import { resultMeta } from '../lib/host/native-result.js'
+
+const filename = '0123456789abcdef0123.native.jpg'
+// Minimal JPEG marker fixture for header parsing; not an image decoder fixture.
+function header(width = 320, height = 640) {
+  const data = Buffer.from([0xff, 0xd8, 0xff, 0xc0, 0x00, 0x11, 0x08,
+    0x00, 0x00, 0x00, 0x00, 0x03, 1, 0x11, 0, 2, 0x11, 0, 3, 0x11, 0, 0xff, 0xd9])
+  data.writeUInt16BE(height, 7)
+  data.writeUInt16BE(width, 9)
+  return data
+}
+async function fixture(t) {
+  const dir = await mkdtemp(join(tmpdir(), 'waves-media-'))
+  t.after(() => rm(dir, { recursive: true, force: true }))
+  const media = join(dir, 'data', 'media')
+  await mkdir(media, { recursive: true })
+  return { dir, media }
+}
+const value = { ok: true, summary: '测试摘要', segments: [{ type: 'html', native_image: filename }] }
+
+test('chat results use file-backed media metadata, never panel asset image views', async (t) => {
+  const { dir, media } = await fixture(t)
+  await writeFile(join(media, filename), header())
+  const meta = resultMeta({ command: 'ww练度' }, value, dir)
+  const result = meta['dsh-go/media']
+  assert.equal(result.v, 1)
+  assert.equal(result.kind, 'image')
+  assert.equal(result.status, 'done')
+  assert.deepEqual(result.items, [{ path: join(media, filename), mime: 'image/jpeg', width: 320, height: 640, bytes: header().length }])
+  assert.equal(result.request.label, '鸣潮')
+  assert.equal(result.request.n, 1)
+  assert.equal(meta['dsh-go/view'], undefined)
+  assert.deepEqual(meta.segments, value.segments)
+})
+
+test('expired or invalid image files degrade to readable text without a broken image', async (t) => {
+  const { dir, media } = await fixture(t)
+  for (const data of [null, Buffer.from('not jpeg'), Buffer.alloc(1048577)]) {
+    if (data) await writeFile(join(media, filename), data)
+    const meta = resultMeta({}, value, dir)
+    assert.equal(meta['dsh-go/media'], undefined)
+    assert.deepEqual(meta['dsh-go/view'].children, [{ type: 'text', text: '测试摘要' }])
+  }
+})
+
+test('chat image metadata cannot reference traversal paths or symlinks outside media directory', async (t) => {
+  const { dir, media } = await fixture(t)
+  const outside = join(dir, 'outside.jpg')
+  await writeFile(outside, header())
+  await symlink(outside, join(media, filename))
+  assert.equal(resultMeta({}, value, dir)['dsh-go/media'], undefined)
+  const traversed = { ...value, segments: [{ type: 'image', native_image: '../../outside.jpg' }] }
+  assert.equal(resultMeta({}, traversed, dir)['dsh-go/media'], undefined)
+})
+
+test('nested image results retain their file dimensions in the chat card', async (t) => {
+  const { dir, media } = await fixture(t)
+  await writeFile(join(media, filename), header(876, 4096))
+  const nested = { ...value, segments: [{ type: 'node', items: value.segments }] }
+  const item = resultMeta({}, nested, dir)['dsh-go/media'].items[0]
+  assert.equal(item.width, 876)
+  assert.equal(item.height, 4096)
+})

package/tests/native.test.js

@@ -0,0 +1,127 @@
+import assert from 'node:assert/strict'
+import { readFileSync, existsSync } from 'node:fs'
+import { pathToFileURL } from 'node:url'
+import { test } from 'node:test'
+import { registerNative } from '../lib/host/native.js'
+import { nativeResultView, plainSummary } from '../lib/host/native-result.js'
+import { makeResultStore, resultText } from '../lib/host/results.js'
+
+const kit = process.env.DSH_GO_KIT
+const scope = { sessionId: 'native-test-session' }
+const caps = { components: ['form', 'gallery'] }
+const groups = [{ name: '服务配置', items: [
+  { key: 'image_ocr', title: 'OCR', desc: '图片摘要', type: 'BoolConfig', value: true },
+  { key: 'WavesToken', title: 'Token', desc: '从文件导入', type: 'StrConfig', value: '已设置', secret: true, is_set: true },
+  { key: 'integer', title: '整数', desc: '', type: 'IntConfig', value: 1 },
+] }]
+
+function fixture() {
+  const panels = new Map()
+  const calls = []
+  const ctx = { dshGo: { panel: (id, def) => panels.set(id, def) }, inject: (_deps, callback) => callback(ctx) }
+  const client = { async call(path, opts = {}) {
+    calls.push({ path, ...opts })
+    if (path === '/api/config' && !opts.method) return { groups }
+    if (path === '/api/config') return { ok: true }
+    return { ok: true, summary: '体力 120/240', segments: [] }
+  } }
+  const results = makeResultStore()
+  registerNative(ctx, client, results)
+  return { panels, calls, results, ctx }
+}
+
+test('native tool cards use safe local images and preserve useful fallback text', () => {
+  const data = { ok: true, summary: '[图文卡片已在界面中展示]\n卡片内容: 体力120/240', segments: [
+    { type: 'html', native_image: '1234567890abcdef1234.native.jpg' },
+    { type: 'image', native_image: '../config.json' },
+  ] }
+  const view = nativeResultView(data)
+  assert.equal(view.children.filter((c) => c.type === 'image').length, 1)
+  assert.equal(view.children[0].src, 'asset:1234567890abcdef1234.native.jpg')
+  assert.match(resultText('查询', data), /120\/240/)
+  assert.doesNotMatch(plainSummary(data), /已在界面/)
+  assert.ok(Buffer.byteLength(JSON.stringify(nativeResultView({ summary: '长'.repeat(10000) }))) <= 8000)
+})
+
+test('native query action uses deferred results and keeps the result scoped to its session', async () => {
+  const { panels, calls, results } = fixture()
+  const query = panels.get('waves-home').actions.query(scope, { value: { values: { 'data.form.command': 'ww体力' } } })
+  assert.equal(query.pending.timeoutMs, 60000)
+  const result = await query.result(new AbortController().signal)
+  assert.match(result.patch.summary, /120\/240/)
+  assert.equal(calls[0].body.native, true)
+  assert.equal(calls[0].body.session_id, scope.sessionId)
+  assert.equal(results.latest(scope.sessionId).command, 'ww体力')
+  assert.equal(results.latest('another-session'), undefined)
+})
+
+test('settings validates identifiers and values and never renders a secret input', async () => {
+  const { panels, calls } = fixture()
+  const settings = panels.get('waves-settings')
+  const edit = panels.get('waves-edit')
+  await settings.actions.edit(scope, { value: { group: '服务配置', key: 'WavesToken' } })
+  const view = await edit.view(scope, caps)
+  assert.doesNotMatch(JSON.stringify(view), /textField|data.form.value/)
+  const secretSave = await edit.actions.save(scope, { value: { values: { 'data.form.value': 'must-not-save' } } }).result(new AbortController().signal)
+  assert.match(secretSave.toast, /文件导入/)
+  assert.equal(calls.filter((c) => c.method === 'POST').length, 0)
+  assert.ok((await settings.actions.edit(scope, { value: { group: '__proto__', key: 'bad' } })).toast)
+  await settings.actions.edit(scope, { value: { group: '服务配置', key: 'integer' } })
+  const rejected = await edit.actions.save(scope, { value: { values: { 'data.form.value': 1.5 } } }).result(new AbortController().signal)
+  assert.match(rejected.toast, /有效数字/)
+})
+
+test('opening a second setting resets the cached editor feed before navigation', async () => {
+  const { panels } = fixture()
+  const editorFeed = { form: { value: 'stale-value' }, notice: 'stale-notice' }
+  const effects = await panels.get('waves-settings').actions.edit(scope, { value: { group: '服务配置', key: 'integer' } })
+  assert.equal(effects[0].type, 'patch')
+  assert.equal(effects[0].id, 'waves-edit')
+  Object.assign(editorFeed, effects[0].data)
+  assert.equal(editorFeed.form.value, 1)
+  assert.equal(editorFeed.notice, '')
+  assert.equal(effects[1].open, 'panel:waves-edit')
+  const secretEffects = await panels.get('waves-settings').actions.edit(scope, { value: { group: '服务配置', key: 'WavesToken' } })
+  assert.equal(secretEffects[0].data.form.value, '')
+})
+
+test('credential files are consumed only during import and never returned in effects', async () => {
+  const { panels, calls, ctx } = fixture()
+  const marker = 'dummy-test-value-not-a-real-token'
+  ctx.dshGo.readPickedFile = (handle) => { assert.equal(handle, 'test-file'); return Buffer.from(marker) }
+  await panels.get('waves-settings').actions.edit(scope, { value: { group: '服务配置', key: 'WavesToken' } })
+  const result = await panels.get('waves-edit').actions['import-file'](scope, { value: { status: 'selected', files: [{ handle: 'test-file' }] } })
+  const saved = calls.find((call) => call.method === 'POST')
+  assert.equal(saved.body.value, marker)
+  assert.doesNotMatch(JSON.stringify(result), new RegExp(marker))
+  assert.equal(result.patch.form.value, '')
+})
+
+test('latest result follows replacement recency across native and slash commands', () => {
+  const store = makeResultStore()
+  store.put('native:s', { sessionId: 's', summary: 'first' })
+  store.put('slash', { sessionId: 's', summary: 'second' })
+  store.put('native:s', { sessionId: 's', summary: 'third' })
+  assert.equal(store.latest('s').summary, 'third')
+})
+
+test('native views and tool card pass the installed App protocol checker', { skip: !kit }, async () => {
+  const { checkView } = await import(pathToFileURL(kit + '/lib/view-check.js').href)
+  const { panels } = fixture()
+  for (const [id, panel] of panels) {
+    const view = await panel.view(scope, caps)
+    const checked = checkView(view, { profile: 'panel', data: { summary: '测试', images: [], form: { command: '', value: true }, notice: '' } })
+    assert.deepEqual(checked.issues.filter((issue) => issue.kind !== 'note'), [], `${id}: ${JSON.stringify(checked.issues)}`)
+  }
+  const image = { type: 'html', native_image: '1234567890abcdef1234.native.jpg' }
+  const value = { ok: true, summary: '体力120/240', segments: [image] }
+  const card = checkView(nativeResultView(value), { profile: 'toolCard' })
+  assert.deepEqual(card.issues.filter((issue) => !(issue.kind === 'note' && issue.path === 'view.accent')), [])
+  const { panels: imagePanels, results } = fixture()
+  results.put('image-test', { ...value, sessionId: scope.sessionId })
+  const home = imagePanels.get('waves-home')
+  const patch = home.actions.latest(scope).patch
+  assert.equal(patch.images[0].src, 'asset:' + image.native_image)
+  const gallery = checkView(await home.view(scope, caps), { profile: 'panel', data: patch })
+  assert.deepEqual(gallery.issues.filter((issue) => !(issue.kind === 'note' && issue.path === 'view.accent')), [])
+})

package/tests/runtime.test.js

@@ -0,0 +1,69 @@
+// Opt-in checks against a real DSH installation, without enabling the plugin.
+// DSH_TEST_RUNTIME=/opt/dsh npm test
+import assert from 'node:assert/strict'
+import { createRequire, registerHooks } from 'node:module'
+import { readFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+import { pathToFileURL } from 'node:url'
+import { test } from 'node:test'
+
+const runtime = process.env.DSH_TEST_RUNTIME
+
+test('installed DSH accepts version ranges and executes both Waves tool definitions', {
+  skip: runtime ? false : 'Set DSH_TEST_RUNTIME to the DSH installation directory',
+}, async () => {
+  const require = createRequire(pathToFileURL(resolve(runtime, 'package.json')))
+  const semver = require('semver')
+  const manifest = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'))
+  assert.ok(semver.satisfies(process.versions.node, manifest.engines.node))
+  for (const [name, range] of Object.entries(manifest.peerDependencies)) {
+    const installed = require(`${name}/package.json`)
+    assert.ok(semver.satisfies(installed.version, range), `${name}@${installed.version} is outside ${range}`)
+    if (name === '@deepseek-ai/dsh-tools') {
+      assert.ok(semver.satisfies(installed.version, manifest.engines.dsh))
+    }
+  }
+
+  // Resolve peer imports from the selected installation only for plugin modules.
+  // No symlinks, dependency installation, profile changes or service startup.
+  const pluginRoot = new URL('../lib/', import.meta.url).href
+  const hooks = registerHooks({
+    resolve(specifier, context, nextResolve) {
+      if (specifier.startsWith('@deepseek-ai/') && context.parentURL?.startsWith(pluginRoot)) {
+        return nextResolve(pathToFileURL(require.resolve(specifier)).href, context)
+      }
+      return nextResolve(specifier, context)
+    },
+  })
+  try {
+    const { registerTool } = await import('../lib/host/tool.js')
+    const { apply } = await import('../lib/index.js')
+    assert.equal(typeof apply, 'function')
+    const tools = []
+    const calls = []
+    const client = { async call(path, options) {
+      calls.push({ path, options })
+      return path === '/api/health' ? { ok: true } : {
+        ok: true, summary: '查询结果', segments: [{ type: 'text', text: '体力 120/240' }],
+      }
+    } }
+    registerTool({ tools: { register: (tool) => tools.push(tool) } }, client, resolve(runtime, 'waves-test-service-not-created'))
+    assert.deepEqual(tools.map((tool) => tool.name), ['waves', 'waves_panel'])
+    const signal = new AbortController().signal
+    for (const [index, args] of [{ command: 'ww体力' }, { char: '椿' }].entries()) {
+      const tool = tools[index]
+      const value = await tool.execute(args, { agent: { id: 'compat-session' }, signal })
+      assert.equal(value.ok, true)
+      assert.deepEqual(tool.output.render(args, value), [{ type: 'text', text: '查询结果' }])
+      assert.deepEqual(tool.output.presentationMeta(args, value).segments, value.segments)
+      assert.equal(tool.presentCall(args).card, 'generic')
+    }
+    assert.deepEqual(calls.map(({ path }) => path), ['/api/health', '/api/chat', '/api/health', '/api/render/panel'])
+    assert.equal(calls[1].options.body.session_id, 'compat-session')
+    assert.equal(calls[3].options.body.char, '椿')
+    await assert.rejects(tools[0].execute({}, { signal }))
+    await assert.rejects(tools[1].execute({ char: 123 }, { signal }))
+  } finally {
+    hooks.deregister()
+  }
+})

package/tests/service.test.js

@@ -0,0 +1,48 @@
+import assert from 'node:assert/strict'
+import { mkdtemp, mkdir, writeFile, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { test } from 'node:test'
+import { bootstrap, waitReady } from '../lib/host/service.js'
+
+async function fixture(t, script) {
+  const root = await mkdtemp(join(tmpdir(), 'waves-setup-'))
+  t.after(() => rm(root, { recursive: true, force: true }))
+  const service = join(root, 'service')
+  await mkdir(service)
+  await writeFile(join(root, 'install.sh'), script)
+  return service
+}
+
+test('bootstrap stays asynchronous and returns installation failure', { skip: process.platform === 'win32' }, async (t) => {
+  const service = await fixture(t, '#!/bin/sh\nsleep 0.1\nexit 7\n')
+  let ticked = false
+  setImmediate(() => { ticked = true })
+  const result = await bootstrap(service, { timeoutMs: 2000 })
+  assert.equal(ticked, true)
+  assert.equal(result.ok, false)
+  assert.match(result.reason, /7/)
+})
+
+test('bootstrap is bounded and can be canceled', { skip: process.platform === 'win32' }, async (t) => {
+  const service = await fixture(t, '#!/bin/sh\nsleep 30\n')
+  const timed = await bootstrap(service, { timeoutMs: 30 })
+  assert.equal(timed.ok, false)
+  assert.match(timed.reason, /超时/)
+  const controller = new AbortController()
+  controller.abort()
+  assert.deepEqual(await bootstrap(service, { signal: controller.signal }), { ok: false, reason: '已取消安装' })
+})
+
+test('bootstrap reports success only for a successful installer', { skip: process.platform === 'win32' }, async (t) => {
+  const service = await fixture(t, '#!/bin/sh\nexit 0\n')
+  assert.equal((await bootstrap(service, { timeoutMs: 2000 })).ok, true)
+})
+
+test('waitReady requires affirmative health and honors cancellation', async () => {
+  assert.equal(await waitReady({ call: async () => ({ ok: false }) }, 0), false)
+  assert.equal(await waitReady({ call: async () => ({ ok: true }) }, 1), true)
+  const controller = new AbortController()
+  controller.abort()
+  assert.equal(await waitReady({ call: () => { throw Error('must not call') } }, 1, controller.signal), false)
+})