dsh-deepmoyu 2.3.0 → 2.4.1

package/tests/pv-stage1.test.mjs

@@ -1,203 +0,0 @@
-import assert from 'node:assert/strict'
-import test from 'node:test'
-import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync, existsSync } from 'node:fs'
-import { dirname, join } from 'node:path'
-import { fileURLToPath } from 'node:url'
-import { setTimeout as delay } from 'node:timers/promises'
-import { createPv, listPv, pvDateOk, pvFileOf, PV_PREFIX } from '../lib/pv.mjs'
-
-const here = dirname(fileURLToPath(import.meta.url))
-const python = process.env.PV_TEST_PYTHON || 'python'
-
-// Minimal valid 1920x1080 / 1440x1080 PNG headers: the coordinator checks
-// dimensions, not pixels. No Pillow is needed by this fixture.
-const FAKE_COVER = String.raw`
-import os, struct, sys, zlib
-from pathlib import Path
-args = sys.argv
-outdir = Path(args[args.index('--outdir') + 1])
-only_missing = '--only-missing' in args
-if os.environ.get('PV_FAKE_COVER_FAIL') == '1':
-    raise SystemExit(3)
-def png(width, height):
-    def chunk(kind, data):
-        return struct.pack('>I', len(data)) + kind + data + struct.pack('>I', zlib.crc32(kind + data) & 0xffffffff)
-    ihdr = struct.pack('>IIBBBBB', width, height, 8, 2, 0, 0, 0)
-    return b'\x89PNG\r\n\x1a\n' + chunk(b'IHDR', ihdr) + chunk(b'IEND', b'')
-for name, size in (('封面_16x9.png', (1920, 1080)), ('封面_4x3.png', (1440, 1080))):
-    target = outdir / name
-    if only_missing and target.is_file() and target.stat().st_size > 24:
-        continue
-    target.parent.mkdir(parents=True, exist_ok=True)
-    target.write_bytes(png(*size))
-`
-
-const FAKE_PLAN = `import json,sys
-from pathlib import Path
-p = Path(sys.argv[sys.argv.index('-o')+1])
-p.write_text(json.dumps({'date': p.stem.replace('plan_',''), 'cover': {'title': '蜻蜓的产房没了'},
-                         'shots': [{'kind': 'story', 'title': '蜻蜓的产房没了', 'text': 'fixture'}]}, ensure_ascii=False), encoding='utf-8')
-`
-
-const FAKE_RENDER = `import os,sys
-from pathlib import Path
-if os.environ.get('PV_FAKE_FAIL') == '1':
-    raise SystemExit(7)
-marker = os.environ.get('PV_RENDER_MARKER')
-if marker:
-    Path(marker).write_text('rendered', encoding='utf-8')
-out = Path(sys.argv[sys.argv.index('--out')+1]); out.parent.mkdir(parents=True, exist_ok=True)
-out.write_bytes(b'new-render' + bytes(1600))
-work = Path(sys.argv[sys.argv.index('--work')+1]); work.mkdir(parents=True, exist_ok=True)
-(work / 'timeline.json').write_text('{}', encoding='utf-8')
-`
-
-async function fixture(run) {
-  const root = mkdtempSync(join(here, '.tmp-pv-'))
-  const state = join(root, 'state')
-  const plugin = join(root, 'plugin')
-  const work = join(root, 'work')
-  const out = join(root, 'out')
-  for (const path of [state, join(plugin, 'lib'), work, out]) mkdirSync(path, { recursive: true })
-  // A stale home copy must never win script selection.
-  for (const name of ['pv.py', 'pv_plan.py', 'pv_cover.py']) {
-    writeFileSync(join(state, name), 'raise RuntimeError("stale home script used")\n')
-  }
-  writeFileSync(join(plugin, 'lib', 'pv_plan.py'), FAKE_PLAN, 'utf-8')
-  writeFileSync(join(plugin, 'lib', 'pv.py'), FAKE_RENDER, 'utf-8')
-  writeFileSync(join(plugin, 'lib', 'pv_cover.py'), FAKE_COVER, 'utf-8')
-  try { await run({ root, state, plugin, work, out }) }
-  finally {
-    assert.ok(root.startsWith(join(here, '.tmp-pv-')))
-    rmSync(root, { recursive: true, force: true })
-  }
-}
-
-async function settled(controller) {
-  for (let attempt = 0; attempt < 300; attempt++) {
-    const state = controller.status()
-    if (state.stage === 'done' || state.stage === 'failed') return state
-    await delay(20)
-  }
-  controller.stop()
-  throw new Error('video coordinator did not settle within test timeout')
-}
-
-const dayDir = (out, day) => join(out, day)
-const dayMovie = (out, day) => join(dayDir(out, day), `${PV_PREFIX}_${day}.mp4`)
-
-test('video dates require real calendar dates', () => {
-  for (const day of ['2024-02-29', '2026-10-21']) assert.equal(pvDateOk(day), true)
-  for (const day of ['2026-02-29', '2026-04-31', '2026-00-01', '2026-1-01', 'foo', '../2026-10-21']) {
-    assert.equal(pvDateOk(day), false)
-  }
-})
-
-test('listing prefers dated folders and still sees legacy flat files', async () => {
-  await fixture(async ({ out }) => {
-    mkdirSync(dayDir(out, '2026-10-21'))
-    writeFileSync(dayMovie(out, '2026-10-21'), Buffer.alloc(1500))
-    writeFileSync(join(out, `${PV_PREFIX}_2026-10-21.mp4`), Buffer.alloc(1300))
-    writeFileSync(join(out, `${PV_PREFIX}_2026-10-20.mp4`), Buffer.alloc(1500))
-    writeFileSync(join(out, `${PV_PREFIX}_2026-10-19.partial.mp4`), Buffer.alloc(1500))
-    writeFileSync(join(out, `${PV_PREFIX}_2026-10-18.mp4`), Buffer.alloc(0))
-    mkdirSync(join(out, `${PV_PREFIX}_2026-10-17.mp4`))
-    mkdirSync(dayDir(out, '2026-13-01'))
-    const rows = listPv(out)
-    assert.deepEqual(rows.map((x) => x.date), ['2026-10-21', '2026-10-20'])
-    assert.equal(rows[0].file, dayMovie(out, '2026-10-21'))
-    assert.equal(rows[0].canonical, true)
-    assert.equal(pvFileOf(out, '2026-10-20'), join(out, `${PV_PREFIX}_2026-10-20.mp4`))
-    assert.equal(pvFileOf(out, '2026-10-18'), dayMovie(out, '2026-10-18'))
-  })
-})
-
-test('successful render publishes movie and both covers into the dated folder', async () => {
-  await fixture(async ({ state, plugin, work, out }) => {
-    const controller = createPv({ stateDir: state, pluginDir: plugin, python: () => python,
-      dirs: () => ({ root: out, out, work, legacy: out, legacyDirs: [out] }),
-      env: { ...process.env, PV_FAKE_FAIL: '0' } })
-    const started = controller.start('2026-10-21', { force: true })
-    assert.equal(started.started, true)
-    const status = await settled(controller)
-    assert.equal(status.stage, 'done', status.tail)
-    assert.equal(status.file, dayMovie(out, '2026-10-21'))
-    assert.equal(readFileSync(dayMovie(out, '2026-10-21')).subarray(0, 10).toString(), 'new-render')
-    assert.equal(readFileSync(join(dayDir(out, '2026-10-21'), '封面_16x9.png')).readUInt32BE(16), 1920)
-    assert.equal(readFileSync(join(dayDir(out, '2026-10-21'), '封面_4x3.png')).readUInt32BE(16), 1440)
-    assert.ok(existsSync(status.plan))
-    assert.ok(existsSync(status.timeline))
-    assert.equal(existsSync(join(out, `${PV_PREFIX}_2026-10-21.mp4`)), false)
-  })
-})
-
-test('failed render retains the previous published movie and covers', async () => {
-  await fixture(async ({ state, plugin, work, out }) => {
-    const movie = dayMovie(out, '2026-10-21')
-    const previous = Buffer.alloc(1400, 66)
-    mkdirSync(dayDir(out, '2026-10-21'))
-    writeFileSync(movie, previous)
-    const controller = createPv({ stateDir: state, pluginDir: plugin, python: () => python,
-      dirs: () => ({ root: out, out, work, legacy: out, legacyDirs: [out] }),
-      env: { ...process.env, PV_FAKE_FAIL: '1' } })
-    controller.start('2026-10-21', { force: true })
-    const status = await settled(controller)
-    assert.equal(status.stage, 'failed')
-    assert.match(status.error, /exit 7/)
-    assert.deepEqual(readFileSync(movie), previous)
-  })
-})
-
-test('cover failure is a package failure, not a silent delivery', async () => {
-  await fixture(async ({ state, plugin, work, out }) => {
-    const controller = createPv({ stateDir: state, pluginDir: plugin, python: () => python,
-      dirs: () => ({ root: out, out, work, legacy: out, legacyDirs: [out] }),
-      env: { ...process.env, PV_FAKE_FAIL: '0', PV_FAKE_COVER_FAIL: '1' } })
-    controller.start('2026-10-21', { force: true })
-    const status = await settled(controller)
-    assert.equal(status.stage, 'failed')
-    assert.match(status.error, /封面生成失败/)
-    assert.equal(existsSync(dayMovie(out, '2026-10-21')), false)
-  })
-})
-
-test('existing movie with missing covers repairs only artwork, never renders', async () => {
-  await fixture(async ({ state, plugin, work, out }) => {
-    const marker = join(out, 'render-was-called')
-    mkdirSync(dayDir(out, '2026-10-21'))
-    const movie = dayMovie(out, '2026-10-21')
-    const previous = Buffer.alloc(1400, 67)
-    writeFileSync(movie, previous)
-    const controller = createPv({ stateDir: state, pluginDir: plugin, python: () => python,
-      dirs: () => ({ root: out, out, work, legacy: out, legacyDirs: [out] }),
-      env: { ...process.env, PV_FAKE_FAIL: '0', PV_RENDER_MARKER: marker } })
-    const started = controller.start('2026-10-21')
-    assert.equal(started.started, true)
-    assert.equal(started.repairing, true)
-    const status = await settled(controller)
-    assert.equal(status.stage, 'done', status.tail)
-    assert.equal(existsSync(marker), false)
-    assert.deepEqual(readFileSync(movie), previous)
-    assert.ok(existsSync(join(dayDir(out, '2026-10-21'), '封面_16x9.png')))
-    assert.ok(existsSync(join(dayDir(out, '2026-10-21'), '封面_4x3.png')))
-  })
-})
-
-test('legacy flat movie is archived without re-rendering the film', async () => {
-  await fixture(async ({ state, plugin, work, out }) => {
-    const marker = join(out, 'render-was-called')
-    const legacy = join(out, `${PV_PREFIX}_2026-10-21.mp4`)
-    const previous = Buffer.alloc(1400, 68)
-    writeFileSync(legacy, previous)
-    const controller = createPv({ stateDir: state, pluginDir: plugin, python: () => python,
-      dirs: () => ({ root: out, out, work, legacy: out, legacyDirs: [out] }),
-      env: { ...process.env, PV_FAKE_FAIL: '0', PV_RENDER_MARKER: marker } })
-    const started = controller.start('2026-10-21')
-    assert.equal(started.repairing, true)
-    const status = await settled(controller)
-    assert.equal(status.stage, 'done', status.tail)
-    assert.equal(existsSync(marker), false)
-    assert.deepEqual(readFileSync(dayMovie(out, '2026-10-21')), previous)
-    assert.ok(existsSync(join(dayDir(out, '2026-10-21'), '封面_4x3.png')))
-  })
-})

package/tests/sticker-routes.test.mjs

@@ -1,141 +0,0 @@
-import test from 'node:test'
-import assert from 'node:assert/strict'
-import { EventEmitter } from 'node:events'
-import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, rmSync } from 'node:fs'
-import { join } from 'node:path'
-import { tmpdir } from 'node:os'
-import { createRequire, syncBuiltinESMExports } from 'node:module'
-import { Readable } from 'node:stream'
-
-const root = mkdtempSync(join(tmpdir(), 'fish-sticker-routes-')), builtin = join(root, 'builtin'), home = join(root, 'bili-duty')
-mkdirSync(builtin); mkdirSync(home)
-const png = Buffer.from('iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+j3ioAAAAASUVORK5CYII=', 'base64')
-writeFileSync(join(builtin, '贴贴.png'), png)
-const priorBuiltin = process.env.DAFEIYU_STICKER_DIR; process.env.DAFEIYU_STICKER_DIR = builtin
-const { apply } = await import('../index.js')
-const { McpClient } = await import('../lib/mcp.mjs')
-
-test('gallery HTTP is safe and on demand; real reply wrapper auto-selects only eligible authorized new comments', async () => {
-  writeFileSync(join(home, 'config.json'), JSON.stringify({ reportLevel: 'off', learnAutoReview: false, autoComment: false, stickerAutoSend: true, stickerSendProbability: 100, stickerSendCooldown: 0 }))
-  const cleanups = [], tools = new Map(), calls = []
-  let handler
-  const agent = { id: 'fish', session: { header: { agentPreset: 'dafeiyu', cwd: root } } }
-  const ctx = { logger: { info() {} }, get: key => key === 'dshHomePath' ? (...parts) => join(root, ...parts) : key === 'agents' ? { list: () => [agent] } : undefined,
-    tools: { register(spec) { tools.set(spec.name, spec); return spec } }, settings: { describe: () => [] }, on() { return () => {} },
-    effect(fn) { const cleanup = fn(); if (typeof cleanup === 'function') cleanups.push(cleanup) },
-    webServer: { register(route) { handler = route.handler; return { dispose() {} } } },
-  }
-  async function request(path, body, method = 'GET', headers = {}) {
-    const req = new EventEmitter(); req.url = '/api/bili-duty' + path; req.method = method; req.headers = headers; req.destroy = () => {}
-    const res = { writeHead(code, headers) { this.code = code; this.headers = headers }, end(data) { this.raw = data; this.body = Buffer.isBuffer(data) || !data ? data : JSON.parse(data) } }
-    const pending = handler(req, res)
-    if (method === 'POST') { req.emit('data', Buffer.from(JSON.stringify(body || {}))); req.emit('end') }
-    await pending; return res
-  }
-  const actualCall = McpClient.prototype.call
-  McpClient.prototype.call = async function(name, args) {
-    calls.push({ name, args })
-    if (name === 'bili_reply') return { success: false, error: 'fixture send rejected; no network' }
-    if (name === 'bili_comments') return { comments: [] }
-    return {}
-  }
-  const reply = (args, fish = true) => tools.get('bili_reply').execute({ bvid: 'BV1234567890', text: '镜头停在倒影上的那几秒，光线变化特别清楚。', ...args }, fish ? { agent } : {})
-  try {
-    apply(ctx, {}); await new Promise(resolve => setImmediate(resolve))
-    const gallery = await request('/stickers')
-    assert.equal(gallery.body.ok, true); assert.deepEqual(gallery.body.counts, { total: 1, builtin: 1, collected: 0 })
-    assert.equal(gallery.body.settings.stickerCollectProbability, 35); assert.equal(gallery.body.capacity, 60)
-    assert.equal(gallery.body.stickers[0].removable, false); assert.ok(!Object.hasOwn(gallery.body.stickers[0], 'file'))
-    const image = await request(gallery.body.stickers[0].imageUrl.replace('/api/bili-duty', ''))
-    assert.equal(image.code, 200); assert.equal(image.headers['content-type'], 'image/png'); assert.deepEqual(image.raw, png)
-    assert.equal((await request('/stickers/image?name=贴贴&source=builtin', null, 'GET', { 'if-none-match': image.headers.etag })).code, 304)
-    for (const query of ['name=..%2Fconfig.json', 'name=贴贴&source=../../', 'name=unknown', '']) assert.equal((await request('/stickers/image?' + query)).code, 404)
-    assert.equal((await request('/stickers/collect', { name: '逃逸', path: join(root, 'private.png') }, 'POST')).body.ok, false)
-    assert.equal((await request('/stickers/collect', { name: '内网', url: 'http://127.0.0.1/secrets' }, 'POST')).body.ok, false)
-    assert.equal((await request('/stickers/forget', { name: '贴贴' }, 'POST')).body.ok, false)
-    assert.equal((await request('/stickers/forget', { name: 'x' }, 'POST', { origin: 'https://outside.example.com' })).code, 403)
-    const copied = await tools.get('bili_sticker').execute({ action: 'collect', name: '别名', path: '贴贴', description: '同一张图换个名字' }, { agent })
-    assert.equal(copied.ok, true)
-    assert.equal((await request('/stickers')).body.counts.collected, 1)
-    assert.equal((await request('/stickers/forget', { name: '别名' }, 'POST')).body.ok, true)
-    const config = (await request('/config', { stickerCollectProbability: 123, stickerCapacity: 999, stickerAutoSend: true }, 'POST')).body
-    assert.equal(config.config.stickerCollectProbability, 100); assert.equal(config.config.stickerCapacity, 60)
-    const blocked = await reply({})
-    assert.equal(blocked.blocked, true); assert.equal(calls.filter(x => x.name === 'bili_reply').length, 0)
-    const sent = await reply({ force: true })
-    assert.equal(sent.auto_picture, '贴贴'); assert.deepEqual(calls.at(-1).args.pictures, [join(builtin, '贴贴.png')])
-    await reply({ force: true, picture: '' }); assert.equal(calls.at(-1).args.pictures, undefined)
-    await reply({ force: true, picture: '贴贴' }); assert.deepEqual(calls.at(-1).args.pictures, [join(builtin, '贴贴.png')])
-    await reply({ force: true, rpid: '123456789' }); assert.equal(calls.at(-1).args.pictures, undefined)
-    await reply({ force: true }, false); assert.equal(calls.at(-1).args.pictures, undefined, 'ordinary mode never auto-attaches fish stickers')
-    const beforeUnknown = calls.length
-    assert.equal((await reply({ force: true, picture: '../private' })).sticker_unknown, true); assert.equal(calls.length, beforeUnknown)
-    assert.equal((await reply({ force: true, rpid: '987654321', picture: '贴贴' })).picture_floor, true)
-    const status = (await request('/status')).body
-    assert.ok(!Object.hasOwn(status, 'stickers')); assert.equal(status.tokensTotal, 0)
-    const unchanged = (await request('/status?rev=' + encodeURIComponent(status.rev))).body
-    assert.equal(unchanged.unchanged, true)
-    assert.equal(JSON.parse(readFileSync(join(home, 'config.json'))).autoComment, false, 'image settings never grant posting authority')
-  } finally {
-    for (const cleanup of cleanups.reverse()) { try { cleanup() } catch {} }
-    McpClient.prototype.call = actualCall
-  }
-})
-
-test.after(() => { if (priorBuiltin === undefined) delete process.env.DAFEIYU_STICKER_DIR; else process.env.DAFEIYU_STICKER_DIR = priorBuiltin; rmSync(root, { recursive: true, force: true }) })
-
-test('session stop cancels only that session collection queue and download; resume accepts a fresh scope', async () => {
-  const isolated = join(root, 'scopes'), duty = join(isolated, 'bili-duty'); mkdirSync(duty, { recursive: true })
-  writeFileSync(join(duty, 'config.json'), JSON.stringify({ reportLevel: 'off', learnAutoReview: false, stickerAutoCollect: true, stickerCollectProbability: 100, stickerCollectCooldown: 0 }))
-  const agents = ['a', 'b'].map(id => ({ id, session: { header: { agentPreset: 'dafeiyu', cwd: isolated } } })), goals = new Map()
-  for (const agent of agents) goals.set(agent.id, { id: agent.id + '-goal', objective: '🐟 鲸鱼摸鱼模式 fixture', phase: 'active', activation: 'armed', revision: 1, roundsStarted: 1, maxGoalRounds: 10 })
-  const cleanups = [], tools = new Map(), require = createRequire(import.meta.url)
-  const http = require('node:https'), dns = require('node:dns'), oldRequest = http.request, oldLookup = dns.promises.lookup
-  const actualCall = McpClient.prototype.call
-  let handler, urlCounter = 0, imageRequests = 0, pendingRequest, requestBegun
-  dns.promises.lookup = async () => [{ address: '8.8.8.8', family: 4 }]
-  // Native transport is intercepted after URL and DNS validation; there is no external connection.
-  http.request = (_url, options, respond) => {
-    const request = new EventEmitter()
-    request.end = () => {
-      imageRequests++
-      if (imageRequests === 1) { pendingRequest = request; requestBegun?.(); return }
-      const response = Readable.from([Buffer.concat([png, Buffer.from(String(imageRequests))])]); response.headers = { 'content-type': 'image/png' }; response.statusCode = 200
-      queueMicrotask(() => respond(response))
-    }
-    const abort = () => request.emit('error', options.signal.reason)
-    options.signal.addEventListener('abort', abort, { once: true })
-    request.once('error', () => options.signal.removeEventListener('abort', abort))
-    return request
-  }
-  syncBuiltinESMExports()
-  McpClient.prototype.call = async function(name) { return name === 'bili_comments' ? { comments: [{ rpid: String(++urlCounter), images: [{ url: 'https://images.example.com/' + urlCounter + '.png', w: 256, h: 256 }] }] } : {} }
-  const services = { dshHomePath: (...parts) => join(isolated, ...parts), agents: { list: () => agents, get: id => agents.find(a => a.id === id) }, goals: { get: agent => goals.get(agent.id), pause(agent) { const g = goals.get(agent.id); g.phase = 'paused'; g.activation = 'disarmed'; return g }, resume(agent) { const g = goals.get(agent.id); g.phase = 'active'; g.activation = 'armed'; return g } } }
-  const ctx = { logger: { info() {} }, get: key => services[key], tools: { register(spec) { tools.set(spec.name, spec); return spec } }, settings: { describe: () => [] }, on() { return () => {} }, effect(fn) { const cleanup = fn(); if (typeof cleanup === 'function') cleanups.push(cleanup) }, webServer: { register(route) { handler = route.handler; return { dispose() {} } } } }
-  async function post(action, agent) {
-    const req = new EventEmitter(); req.url = '/api/bili-duty/feiyu'; req.method = 'POST'; req.headers = {}; req.destroy = () => {}
-    const res = { writeHead() {}, end(text) { this.body = JSON.parse(text) } }, promise = handler(req, res)
-    req.emit('data', Buffer.from(JSON.stringify({ action, sessionId: agent.id }))); req.emit('end'); await promise; return res.body
-  }
-  const comments = agent => tools.get('bili_comments').execute({ bvid: 'BV1234567890' }, { agent })
-  const flush = () => new Promise(resolve => setImmediate(resolve))
-  const collected = () => Object.keys(JSON.parse(readFileSync(join(duty, 'state.json'), 'utf8')).stickers || {})
-  try {
-    apply(ctx, {}); await flush()
-    await comments(agents[0]); await post('stop', agents[0]); await flush()
-    assert.equal(imageRequests, 0, 'queued download is withdrawn even though host tool signal is absent')
-    assert.equal((await post('resume', agents[0])).ok, true)
-    const begun = new Promise(resolve => { requestBegun = resolve })
-    await comments(agents[0]); await begun
-    await comments(agents[1]); await post('stop', agents[0]); await flush(); await flush()
-    assert.ok(pendingRequest.listenerCount('error') > 0)
-    assert.equal(imageRequests, 2, 'other session continues after one session stops')
-    assert.equal(collected().length, 1, 'stopped inflight session never commits')
-    assert.equal((await post('resume', agents[0])).ok, true)
-    await comments(agents[0]); await flush(); await flush()
-    assert.equal(imageRequests, 3); assert.equal(collected().length, 2, 'resumed session gets a fresh collection scope')
-  } finally {
-    for (const cleanup of cleanups.reverse()) { try { cleanup() } catch {} }
-    http.request = oldRequest; dns.promises.lookup = oldLookup; McpClient.prototype.call = actualCall; syncBuiltinESMExports()
-  }
-})

package/tests/sticker-upload-routes.test.mjs

@@ -1,97 +0,0 @@
-import test from 'node:test'
-import assert from 'node:assert/strict'
-import { EventEmitter } from 'node:events'
-import { createServer, request as httpRequest } from 'node:http'
-import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, rmSync } from 'node:fs'
-import { join } from 'node:path'
-import { tmpdir } from 'node:os'
-
-const root = mkdtempSync(join(tmpdir(), 'fish-sticker-upload-route-')), builtin = join(root, 'builtin'), home = join(root, 'bili-duty')
-mkdirSync(builtin); mkdirSync(home)
-const dataBase64 = 'iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAAEklEQVR4nGP8r+DAwMDAxAAGABFdAWPYSWFdAAAAAElFTkSuQmCC'
-const gif = Buffer.from('R0lGODdhAgACAIEAAP8gQAAAAAAAAAAAACwAAAAAAgACAAAIBgABCAQQEAA7', 'base64')
-writeFileSync(join(builtin, '内置.gif'), gif)
-const priorBuiltin = process.env.DAFEIYU_STICKER_DIR; process.env.DAFEIYU_STICKER_DIR = builtin
-const { apply } = await import('../index.js')
-const cleanups = [], tools = new Map()
-let handler
-const ctx = { logger: { info() {} }, get: key => key === 'dshHomePath' ? (...parts) => join(root, ...parts) : undefined,
-  tools: { register(spec) { tools.set(spec.name, spec); return spec } }, settings: { describe: () => [] }, on() { return () => {} },
-  effect(fn) { const cleanup = fn(); if (typeof cleanup === 'function') cleanups.push(cleanup) },
-  webServer: { register(route) { handler = route.handler; return { dispose() {} } } },
-}
-
-async function mockRequest(path, raw, headers = {}, chunks) {
-  const req = new EventEmitter(); req.url = '/api/bili-duty' + path; req.method = 'POST'; req.headers = headers
-  let destroyed = false; req.destroy = () => { destroyed = true }
-  const res = { writeHead(status, headers) { this.status = status; this.headers = headers }, end(data) { this.body = JSON.parse(data) } }
-  const pending = handler(req, res)
-  for (const bytes of chunks || [Buffer.from(raw)]) req.emit('data', bytes)
-  req.emit('end'); await pending
-  return { ...res, destroyed }
-}
-const post = (body, headers, chunks) => mockRequest('/stickers/upload', JSON.stringify(body), headers, chunks)
-
-writeFileSync(join(home, 'config.json'), JSON.stringify({ reportLevel: 'off', learnAutoReview: false, autoComment: false, autoDm: false, autoMoment: false }))
-apply(ctx, {})
-
-test.after(() => {
-  for (const cleanup of cleanups.reverse()) { try { cleanup() } catch {} }
-  if (priorBuiltin === undefined) delete process.env.DAFEIYU_STICKER_DIR; else process.env.DAFEIYU_STICKER_DIR = priorBuiltin
-  rmSync(root, { recursive: true, force: true })
-})
-
-test('HTTP upload provides stable errors, preserves Origin and posting gates, and exposes safe gallery image URL', async () => {
-  assert.equal((await post({ name: '跨站', dataBase64 }, { origin: 'https://outside.example.com' })).status, 403)
-  for (const body of [null, [], { name: '只给路径', path: join(builtin, '内置.gif') }, { name: '../escape', dataBase64 }, { name: '坏编码', dataBase64: 'a===' }]) {
-    const result = await post(body); assert.equal(result.status, 400); assert.equal(result.body.ok, false)
-  }
-  assert.equal((await mockRequest('/stickers/upload', '{broken')).body.code, 'INVALID_JSON')
-  const bad = await post({ name: '伪图片', dataBase64: Buffer.from('hello world and not image').toString('base64') })
-  assert.equal(bad.status, 415); assert.equal(bad.body.code, 'STICKER_IMAGE_INVALID')
-  const oversized = await post({ name: '字节超限', dataBase64: Buffer.alloc(5 * 1024 * 1024 + 1).toString('base64') })
-  assert.equal(oversized.status, 413); assert.equal(oversized.body.code, 'STICKER_TOO_LARGE'); assert.equal(oversized.destroyed, false)
-  // Size of the optional description pushes this otherwise valid upload beyond the old 1MB request limit.
-  const body = { name: '本地图片', filename: 'from-device.jpg', dataBase64, description: '本地备注'.repeat(150000), tags: ['开心'] }
-  const raw = Buffer.from(JSON.stringify(body)), firstChinese = raw.indexOf(Buffer.from('本'))
-  assert.ok(raw.length > 1_000_000)
-  const added = await post(body, { origin: 'http://127.0.0.1:43129' }, [raw.subarray(0, firstChinese + 1), raw.subarray(firstChinese + 1, 500000), raw.subarray(500000)])
-  assert.equal(added.status, 200); assert.deepEqual(added.body, { ok: true, name: '本地图片', bytes: Buffer.from(dataBase64, 'base64').length, mime: 'image/png', source: 'collected', imageUrl: '/api/bili-duty/stickers/image?name=' + encodeURIComponent('本地图片') + '&source=collected' })
-  assert.ok(!Object.hasOwn(added.body, 'file'))
-  const duplicate = await post({ name: '同内容', dataBase64 }); assert.equal(duplicate.status, 409); assert.equal(duplicate.body.duplicate, true)
-  const config = JSON.parse(readFileSync(join(home, 'config.json')))
-  assert.equal(config.autoComment, false); assert.equal(config.autoDm, false); assert.equal(config.autoMoment, false)
-  const state = JSON.parse(readFileSync(join(home, 'state.json')))
-  assert.equal(state.stickers.本地图片.description.length, 160); assert.equal(state.stickers.本地图片.file, '本地图片.png')
-  assert.deepEqual(readFileSync(join(builtin, '内置.gif')), gif)
-})
-
-test('HTTP body overrun returns 413 without destroying the request; default routes keep the 1MB limit', async () => {
-  const overrun = await mockRequest('/stickers/upload', '', {}, [Buffer.alloc(7 * 1024 * 1024 + 1, 32), Buffer.from('ignored after limit')])
-  assert.equal(overrun.status, 413); assert.equal(overrun.body.code, 'REQUEST_TOO_LARGE'); assert.equal(overrun.destroyed, false)
-  const declared = await mockRequest('/stickers/upload', '', { 'content-length': String(7 * 1024 * 1024 + 1) })
-  assert.equal(declared.status, 413); assert.equal(declared.body.code, 'REQUEST_TOO_LARGE'); assert.equal(declared.destroyed, false)
-  const defaults = await mockRequest('/stickers/collect', JSON.stringify({ name: '超默认请求体', description: 'x'.repeat(1_000_001) }))
-  assert.equal(defaults.body.ok, false); assert.equal(defaults.destroyed, false)
-})
-
-test('real loopback transport receives JSON for a chunked upload overrun and remains usable', async () => {
-  const server = createServer((req, res) => { void handler(req, res) })
-  await new Promise(resolve => server.listen(0, '127.0.0.1', resolve))
-  const address = server.address()
-  const call = (path, chunks) => new Promise((resolve, reject) => {
-    const req = httpRequest({ host: '127.0.0.1', port: address.port, path: '/api/bili-duty' + path, method: 'POST', headers: { 'content-type': 'application/json' } }, res => {
-      const data = []; res.on('data', bytes => data.push(bytes)); res.on('end', () => resolve({ status: res.statusCode, body: JSON.parse(Buffer.concat(data)) }))
-    })
-    req.on('error', reject)
-    req.setTimeout(10000, () => req.destroy(new Error('fixture request timed out')))
-    for (const bytes of chunks) req.write(bytes)
-    req.end()
-  })
-  try {
-    const tooLarge = await call('/stickers/upload', [Buffer.alloc(7 * 1024 * 1024, 32), Buffer.from('extra')])
-    assert.equal(tooLarge.status, 413); assert.equal(tooLarge.body.code, 'REQUEST_TOO_LARGE')
-    const after = await call('/stickers/forget', [Buffer.from(JSON.stringify({ name: '本地图片' }))])
-    assert.equal(after.status, 200); assert.equal(after.body.ok, true)
-  } finally { server.closeAllConnections(); await new Promise(resolve => server.close(resolve)) }
-})

package/tests/sticker-upload.test.mjs

@@ -1,122 +0,0 @@
-import test from 'node:test'
-import assert from 'node:assert/strict'
-import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, readdirSync, rmSync } from 'node:fs'
-import { join } from 'node:path'
-import { tmpdir } from 'node:os'
-import { deflateSync } from 'node:zlib'
-
-// Pillow-generated standard 2x2 RGB images. Tests need no decoder dependency or external process.
-const fixtures = {
-  png: 'iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAAEklEQVR4nGP8r+DAwMDAxAAGABFdAWPYSWFdAAAAAElFTkSuQmCC',
-  jpg: '/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCAACAAIDASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwDFoooryz9hP//Z',
-  gif: 'R0lGODdhAgACAIEAAP8gQAAAAAAAAAAAACwAAAAAAgACAAAIBgABCAQQEAA7',
-  webp: 'UklGRjoAAABXRUJQVlA4IC4AAACQAQCdASoCAAIAAUAmJaACdLoAA5gA/u1N38bzea1rf/ybL/y0L/y0L/knAAAA',
-}
-const root = mkdtempSync(join(tmpdir(), 'fish-sticker-upload-')), builtin = join(root, 'builtin')
-mkdirSync(builtin)
-const builtinBytes = Buffer.from(fixtures.gif, 'base64')
-writeFileSync(join(builtin, '内置.gif'), builtinBytes)
-const priorBuiltin = process.env.DAFEIYU_STICKER_DIR
-process.env.DAFEIYU_STICKER_DIR = builtin
-const { uploadSticker, collectSticker, listStickers, readStickerImage, forgetSticker, STICKER_BYTES_MAX } = await import('../lib/sticker.mjs')
-const { validateStickerImage } = await import('../lib/sticker-image.mjs')
-let sequence = 0
-const home = () => { const path = join(root, 'home-' + ++sequence); mkdirSync(path); writeFileSync(join(path, 'state.json'), JSON.stringify({ tokensTotal: 888, retained: { value: true } })); return path }
-const upload = (path, name = '本地图', dataBase64 = fixtures.png, extra = {}) => uploadSticker(path, { name, dataBase64, ...extra })
-const png = Buffer.from(fixtures.png, 'base64')
-
-// Build well-formed PNG chunks for exact-boundary and decompression-limit checks.
-const crc32 = bytes => {
-  let crc = 0xffffffff
-  for (const byte of bytes) { crc ^= byte; for (let bit = 0; bit < 8; bit++) crc = crc & 1 ? 0xedb88320 ^ (crc >>> 1) : crc >>> 1 }
-  return (crc ^ 0xffffffff) >>> 0
-}
-const chunk = (type, data) => {
-  const kind = Buffer.from(type), out = Buffer.alloc(data.length + 12)
-  out.writeUInt32BE(data.length); kind.copy(out, 4); data.copy(out, 8); out.writeUInt32BE(crc32(Buffer.concat([kind, data])), data.length + 8)
-  return out
-}
-const paddedPng = size => Buffer.concat([png.subarray(0, -12), chunk('tEXt', Buffer.alloc(size - png.length - 12, 65)), png.subarray(-12)])
-
-test.after(() => { if (priorBuiltin === undefined) delete process.env.DAFEIYU_STICKER_DIR; else process.env.DAFEIYU_STICKER_DIR = priorBuiltin; rmSync(root, { recursive: true, force: true }) })
-
-test('upload accepts standard PNG/JPEG/GIF/WebP bytes and actual format wins over filename', () => {
-  for (const [fmt, dataBase64] of Object.entries(fixtures)) {
-    const dir = home()
-    // GIF fixture belongs to the built-in area; use the same validation directly for that format.
-    validateStickerImage(Buffer.from(dataBase64, 'base64'), fmt)
-    const result = upload(dir, '本地 图片.png', dataBase64, { filename: 'wrong-extension.txt', description: '本地挑选', tags: ['高兴', '贴贴'] })
-    if (fmt === 'gif') { assert.equal(result.duplicate, true); continue }
-    assert.equal(result.ok, true, `${fmt}: ${result.error}`); assert.equal(result.name, '本地-图片'); assert.equal(result.fmt, fmt)
-    assert.equal(result.mime, { jpg: 'image/jpeg', png: 'image/png', webp: 'image/webp' }[fmt]); assert.equal(result.from, 'local upload: wrong-extension.txt')
-    assert.equal(result.sourceUrl, ''); assert.equal(result.automatic, false)
-    assert.deepEqual(readStickerImage(dir, result.name, 'collected').bytes, Buffer.from(dataBase64, 'base64'))
-    const state = JSON.parse(readFileSync(join(dir, 'state.json')))
-    assert.equal(state.tokensTotal, 888); assert.deepEqual(state.retained, { value: true }); assert.deepEqual(state.stickers[result.name].tags, ['高兴', '贴贴'])
-    assert.match(state.stickers[result.name].hash, /^[a-f0-9]{64}$/)
-    assert.equal(forgetSticker(dir, result.name).ok, true)
-  }
-})
-
-test('upload accepts a distinct GIF, animated GIF/WebP, lossless WebP and progressive JPEG', () => {
-  const variants = [
-    ['gif', 'R0lGODdhAgACAIEAABQ8eAAAAAAAAAAAACwAAAAAAgACAAAIBgABCAQQEAA7'],
-    ['webp', 'UklGRh4AAABXRUJQVlA4TBEAAAAvAUAAAAdQnlIUr/+BiOh/AAA='],
-    ['webp', 'UklGRsAAAABXRUJQVlA4WAoAAAACAAAAAQAAAQAAQU5JTQYAAAAAAAAAAABBTk1GQgAAAAAAAAAAAAEAAAEAAGQAAAJWUDggKgAAADABAJ0BKgIAAgABQCYloAADcAD++F9///xvH+u7/KLgu//rb8c/mvAwAEFOTUZKAAAAAAAAAAAAAQAAAQAAZAAAAFZQOCAyAAAANAEAnQEqAgACAAAAJiWgAANwAP7y63//+bA/9vP/BHoB///S4P/+lwf/9Lg/9KQAAAA='],
-    ['gif', 'R0lGODlhAgACAIEAABQ8eAAAAAAAAAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQACgAAACwAAAAAAgACAAAIBgABCAQQEAAh+QQBCgABACwAAAAAAgACAIH/AAAAAAAAAAAAAAAIBgABCAQQEAA7'],
-    ['jpg', '/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wgARCAACAAIDASIAAhEBAxEB/8QAFQABAQAAAAAAAAAAAAAAAAAAAAb/xAAVAQEBAAAAAAAAAAAAAAAAAAAEBf/aAAwDAQACEAMQAAABmhQJ/8QAFBABAAAAAAAAAAAAAAAAAAAAAP/aAAgBAQABBQJ//8QAFBEBAAAAAAAAAAAAAAAAAAAAAP/aAAgBAwEBPwF//8QAFBEBAAAAAAAAAAAAAAAAAAAAAP/aAAgBAgEBPwF//8QAFBABAAAAAAAAAAAAAAAAAAAAAP/aAAgBAQAGPwJ//8QAFBABAAAAAAAAAAAAAAAAAAAAAP/aAAgBAQABPyF//9oADAMBAAIAAwAAABD7/8QAFBEBAAAAAAAAAAAAAAAAAAAAAP/aAAgBAwEBPxB//8QAFBEBAAAAAAAAAAAAAAAAAAAAAP/aAAgBAgEBPxB//8QAFBABAAAAAAAAAAAAAAAAAAAAAP/aAAgBAQABPxB//9k='],
-  ]
-  for (const [fmt, dataBase64] of variants) {
-    const result = upload(home(), '多种编码', dataBase64)
-    assert.equal(result.ok, true, `${fmt}: ${result.error}`); assert.equal(result.fmt, fmt)
-  }
-})
-
-test('upload rejects invalid JSON field types, arbitrary paths and noncanonical base64 without storing anything', () => {
-  const dir = home(), before = readFileSync(join(dir, 'state.json'), 'utf8')
-  for (const options of [null, [], { name: {}, dataBase64: fixtures.png }, { name: '../escape', dataBase64: fixtures.png }, { name: 'con', dataBase64: fixtures.png },
-    { name: '图', path: join(builtin, '内置.gif') }, { name: '图', dataBase64: fixtures.png, filename: 'C:\\private.png' },
-    { name: '图', dataBase64: fixtures.png, description: {} }, { name: '图', dataBase64: fixtures.png, tags: [123] },
-    { name: '图', dataBase64: '' }, { name: '图', dataBase64: 'data:image/png;base64,' + fixtures.png },
-    { name: '图', dataBase64: fixtures.png + '\n' }, { name: '图', dataBase64: 'AB==' }, { name: '图', dataBase64: '!!!!' }, { name: '图', dataBase64: 'AAAA=' }]) {
-    assert.equal(uploadSticker(dir, options).code, 'STICKER_INPUT', JSON.stringify(options))
-  }
-  assert.equal(readFileSync(join(dir, 'state.json'), 'utf8'), before); assert.equal(listStickers(dir, { source: 'collected' }).length, 0)
-})
-
-test('upload detects non-images, header-only files, missing terminators, malformed chunk lengths and CRC corruption', () => {
-  const dir = home()
-  const broken = [Buffer.from('<html>not an image</html>'), Buffer.from('<svg xmlns="http://www.w3.org/2000/svg"/>')]
-  for (const [fmt, encoded] of Object.entries(fixtures)) {
-    const bytes = Buffer.from(encoded, 'base64')
-    broken.push(bytes.subarray(0, 12), bytes.subarray(0, -1), bytes.subarray(0, Math.floor(bytes.length / 2)))
-    if (fmt === 'png') { const corrupt = Buffer.from(bytes); corrupt[45] ^= 1; broken.push(corrupt) }
-    if (fmt === 'webp') { const corrupt = Buffer.from(bytes); corrupt.writeUInt32LE(0x7fffffff, 16); broken.push(corrupt) }
-  }
-  for (const bytes of broken) assert.equal(upload(dir, '坏图', bytes.toString('base64')).code, 'STICKER_IMAGE_INVALID')
-  assert.equal(listStickers(dir, { source: 'collected' }).length, 0)
-})
-
-test('upload accepts exactly 5MiB, rejects one byte over and bounds PNG decompression', () => {
-  const accepted = paddedPng(STICKER_BYTES_MAX)
-  assert.equal(upload(home(), '边界', accepted.toString('base64')).ok, true)
-  assert.equal(upload(home(), '超限', Buffer.concat([accepted, Buffer.from([0])]).toString('base64')).code, 'STICKER_TOO_LARGE')
-  const header = Buffer.from(png.subarray(16, 29)); header.writeUInt32BE(65535, 0); header.writeUInt32BE(65535, 4)
-  const bomb = Buffer.concat([png.subarray(0, 8), chunk('IHDR', header), chunk('IDAT', deflateSync(Buffer.from([0]))), chunk('IEND', Buffer.alloc(0))])
-  assert.match(upload(home(), '解压超限', bomb.toString('base64')).error, /64MB/)
-})
-
-test('upload shares names, capacity, content dedupe, state merge and builtin protection with collection', async () => {
-  const dir = home()
-  assert.equal(upload(dir, '内置').code, 'STICKER_NAME_EXISTS')
-  assert.equal(upload(dir, '同内置', fixtures.gif).duplicate, true)
-  assert.equal(upload(dir, '第一张').ok, true)
-  const duplicate = upload(dir, '不同名字'); assert.equal(duplicate.code, 'STICKER_DUPLICATE'); assert.equal(duplicate.name, '第一张')
-  assert.equal((await collectSticker(dir, { name: '下载同图', url: 'https://images.example.com/a.png', lookupImpl: async () => [{ address: '8.8.8.8', family: 4 }], fetchImpl: async () => new Response(png) })).duplicate, true)
-  assert.equal(upload(dir, '第二张', fixtures.jpg, { capacity: 1 }).code, 'STICKER_CAPACITY')
-  assert.equal(listStickers(dir, { source: 'collected' }).length, 1)
-  assert.deepEqual(readFileSync(join(builtin, '内置.gif')), builtinBytes)
-  const stateFile = join(dir, 'state.json'); writeFileSync(stateFile, '{broken')
-  assert.equal(upload(dir, '账本坏了', fixtures.webp).code, 'STICKER_STORAGE'); assert.equal(readFileSync(stateFile, 'utf8'), '{broken')
-  assert.deepEqual(readdirSync(join(dir, 'stickers')), ['第一张.png'])
-})