@fg-lab/amadeus-qq 0.0.0-stage → 1.2.2

package/preset.patch.yml

@@ -0,0 +1,166 @@
+# Dedicated DSH Agent preset shipped by the same @fg-lab/amadeus-qq package.
+# It declares only the QQ platform operation contract (tool boundary) and no
+# persona or character card. The guard lives with the preset, so a persisted QQ
+# Session keeps its tool boundary even when the connector is disabled or absent.
+- insert:
+    - id: preset-amadeus-qq
+      name: '@deepseek-ai/dsh-agent-preset'
+      config:
+        id: amadeus-qq
+        name: Amadeus QQ
+        description: Restricted continuous QQ conversation Session
+        order: 20
+        plugins:
+          - id: qq-tool-boundary
+            # Mount the package root here. DSH's preset registry resolves the
+            # package root reliably; a package subpath export imports under
+            # plain Node but leaves this row "never started" in the registry.
+            name: '@fg-lab/amadeus-qq'
+            config:
+              presetGuard: true
+    - id: preset-amadeus-qq-search
+      name: '@deepseek-ai/dsh-agent-preset'
+      config:
+        id: amadeus-qq-search
+        name: Amadeus QQ Search
+        description: Restricted QQ conversation with the Host web search boundary
+        order: 21
+        plugins:
+          - id: qq-web-search
+            name: '@deepseek-ai/dsh-tool-web'
+            config:
+              search: true
+              fetch: false
+              searchTimeoutMs: 60000
+          - id: qq-search-boundary
+            name: '@fg-lab/amadeus-qq'
+            config:
+              presetGuard: true
+              allowSearch: true
+    - id: preset-amadeus-qq-media
+      name: '@deepseek-ai/dsh-agent-preset'
+      config:
+        id: amadeus-qq-media
+        name: Amadeus QQ Media
+        description: Restricted QQ conversation with an enhanced media read boundary
+        order: 22
+        plugins:
+          - id: qq-media-boundary
+            name: '@fg-lab/amadeus-qq'
+            config:
+              presetGuard: true
+              level: 2
+    - id: preset-amadeus-qq-media-search
+      name: '@deepseek-ai/dsh-agent-preset'
+      config:
+        id: amadeus-qq-media-search
+        name: Amadeus QQ Media Search
+        description: Restricted QQ conversation with enhanced media read and Host web search
+        order: 23
+        plugins:
+          - id: qq-media-web-search
+            name: '@deepseek-ai/dsh-tool-web'
+            config:
+              search: true
+              fetch: false
+              searchTimeoutMs: 60000
+          - id: qq-media-search-boundary
+            name: '@fg-lab/amadeus-qq'
+            config:
+              presetGuard: true
+              level: 2
+              allowSearch: true
+    - id: preset-amadeus-qq-owner
+      name: '@deepseek-ai/dsh-agent-preset'
+      config:
+        id: amadeus-qq-owner
+        name: Amadeus QQ Owner
+        description: Restricted Owner workspace; selected only for a trusted Owner Agent Scene
+        order: 24
+        plugins:
+          - id: qq-owner-boundary
+            # Level 4 guards the QQ tool surface. The Owner workspace tool is
+            # mounted only after an operator supplies ownerWorkspaceRoot; until
+            # then Settings shows it as pending and no file tool exists.
+            name: '@fg-lab/amadeus-qq'
+            config:
+              presetGuard: true
+              level: 4
+          - id: owner-tool-pwsh
+            name: '@deepseek-ai/dsh-tool-pwsh'
+          - id: owner-tool-fs
+            name: '@deepseek-ai/dsh-tool-fs'
+          - id: owner-tool-fs-search
+            name: '@deepseek-ai/dsh-tool-fs-search'
+            config:
+              sampleOverCapGlobResults: false
+          - id: owner-tool-jobs
+            name: '@deepseek-ai/dsh-tool-jobs'
+          - id: owner-tool-web
+            name: '@deepseek-ai/dsh-tool-web'
+            config:
+              search: true
+              fetch: true
+    - id: preset-amadeus-qq-life
+      name: '@deepseek-ai/dsh-agent-preset'
+      config:
+        id: amadeus-qq-life
+        name: Amadeus QQ Life
+        description: Restricted QQ conversation with explicit Life read access
+        order: 25
+        plugins:
+          - id: qq-life-boundary
+            name: '@fg-lab/amadeus-qq'
+            config:
+              presetGuard: true
+              allowLifeRead: true
+    - id: preset-amadeus-qq-life-search
+      name: '@deepseek-ai/dsh-agent-preset'
+      config:
+        id: amadeus-qq-life-search
+        name: Amadeus QQ Life Search
+        description: Restricted QQ conversation with Life read access and Host web search
+        order: 26
+        plugins:
+          - id: qq-life-search-boundary
+            name: '@fg-lab/amadeus-qq'
+            config:
+              presetGuard: true
+              allowLifeRead: true
+              allowSearch: true
+    - id: preset-amadeus-qq-life-media
+      name: '@deepseek-ai/dsh-agent-preset'
+      config:
+        id: amadeus-qq-life-media
+        name: Amadeus QQ Life Media
+        description: Restricted QQ conversation with Life and media read access
+        order: 27
+        plugins:
+          - id: qq-life-media-boundary
+            name: '@fg-lab/amadeus-qq'
+            config:
+              presetGuard: true
+              level: 2
+              allowLifeRead: true
+    - id: preset-amadeus-qq-life-media-search
+      name: '@deepseek-ai/dsh-agent-preset'
+      config:
+        id: amadeus-qq-life-media-search
+        name: Amadeus QQ Life Media Search
+        description: Restricted QQ conversation with Life, media read access and Host web search
+        order: 28
+        plugins:
+          - id: qq-life-media-web-search
+            name: '@deepseek-ai/dsh-tool-web'
+            config:
+              search: true
+              fetch: false
+              searchTimeoutMs: 60000
+          - id: qq-life-media-search-boundary
+            name: '@fg-lab/amadeus-qq'
+            config:
+              presetGuard: true
+              level: 2
+              allowLifeRead: true
+              allowSearch: true
+

package/screenshots.json

@@ -0,0 +1,6 @@
+[
+  "docs/screenshots/v1.2-overview.png",
+  "docs/screenshots/global-desktop.png",
+  "docs/screenshots/account-browser.png",
+  "docs/screenshots/account-dark-browser.png"
+]

package/scripts/build-client.mjs

@@ -0,0 +1,52 @@
+/**
+ * Build the browser half as a DSH lazy-CJS module.
+ * The template is plain JavaScript (no ESM import/export); this script wraps it
+ * in the official ModuleLoader format and verifies the result parses.
+ */
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import vm from 'node:vm'
+
+const root = dirname(dirname(fileURLToPath(import.meta.url)))
+const templatePath = join(root, 'src', 'client', 'factory.template.js')
+const logicPath = join(root, 'src', 'client', 'logic.js')
+const outputPath = join(root, 'lib', 'client.js')
+
+const template = readFileSync(templatePath, 'utf8')
+const logic = readFileSync(logicPath, 'utf8').replace(/^export\s+/gm, '')
+for (const source of [template, logic]) {
+  if (/^\s*(import|export)\s/m.test(source)) {
+    throw new Error('client factory must not contain ESM import/export statements')
+  }
+}
+
+const body = template.replace('__CLIENT_LOGIC__', logic)
+if (body.includes('__CLIENT_LOGIC__')) throw new Error('client logic placeholder was not replaced')
+
+const bundle = `window.__ModuleLoader__.load({
+  id: '@fg-lab/amadeus-qq',
+  factory: (require) => {
+    const React = require('react');
+    const h = React.createElement;
+${body}
+  }
+});
+`
+
+new vm.Script(bundle, { filename: 'lib/client.js' })
+
+for (const marker of [
+  'settings.section',
+  "id: 'amadeus-qq'",
+  "/api/amadeus-qq",
+  "credentials: 'same-origin'",
+  '打开 Web Console',
+  '开始首次设置',
+]) {
+  if (!bundle.includes(marker)) throw new Error(`client bundle is missing required marker: ${marker}`)
+}
+
+mkdirSync(dirname(outputPath), { recursive: true })
+writeFileSync(outputPath, bundle, 'utf8')
+process.stdout.write(`built lib/client.js (${Buffer.byteLength(bundle)} bytes)\n`)

package/scripts/registry-guard.mjs

@@ -0,0 +1,12 @@
+import fs from 'node:fs';
+import assert from 'node:assert/strict';
+
+const pkg=JSON.parse(fs.readFileSync(new URL('../package.json',import.meta.url),'utf8'));
+assert.match(pkg.name,/^@fg-lab\/amadeus-(qq|memory|life|state|persona)$/);
+assert.match(pkg.version,/^\d+\.\d+\.\d+$/);
+assert.notEqual(pkg.private,true,'Private packages cannot be published');
+assert.equal(pkg.publishConfig?.access,'public');
+const response=await fetch('https://registry.npmjs.org/'+encodeURIComponent(pkg.name)+'/'+encodeURIComponent(pkg.version),{signal:AbortSignal.timeout(20000)});
+if(response.status===200)throw new Error('This npm version already exists; never overwrite or reuse it.');
+if(response.status!==404)throw new Error('Registry availability could not be verified (HTTP '+response.status+'); stop publishing.');
+console.log('Registry preflight: target version does not exist. Scope authorization still requires npm authentication.');

package/scripts/release-audit.mjs

@@ -0,0 +1,59 @@
+import { execSync } from 'node:child_process'
+import { readFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+
+const pkg = JSON.parse(readFileSync('package.json', 'utf8'))
+const requirements = {
+  '@fg-lab/amadeus-qq': ['src/index.js', 'lib/client.js', 'src/console/index.html', 'src/console/console.js', 'src/console/console.css', 'cordis.patch.yml', 'preset.patch.yml'],
+  '@fg-lab/amadeus-memory': ['lib/index.js', 'lib/client.js', 'cordis.patch.yml', 'runtime-manifest.json'],
+  '@fg-lab/amadeus-life': ['src/index.js', 'lib/client.js', 'cordis.patch.yml', 'icon.svg', 'locale/zh.json', 'locale/en.json'],
+  '@fg-lab/amadeus-state': ['src/index.js', 'lib/client.js', 'cordis.patch.yml', 'icon.svg', 'locale/zh.json', 'locale/en.json'],
+  '@fg-lab/amadeus-persona': ['src/index.js', 'src/client.js', 'src/console/index.html', 'src/console/console.js', 'src/console/console.css', 'cordis.patch.yml']
+}
+for (const required of Object.values(requirements)) required.push('assets/market-icon.png', 'screenshots.json', 'docs/INSTALL_V1_2.md')
+if (pkg.license === 'MIT') requirements[pkg.name]?.push('LICENSE')
+const expectedId = pkg.name === '@fg-lab/amadeus-memory' ? 'dsh-mneme' : pkg.name.replace('@fg-lab/', '')
+const errors = []
+const warnings = []
+if (!requirements[pkg.name]) errors.push(`unexpected package name: ${pkg.name}`)
+if (pkg.scripts?.prepare || pkg.scripts?.postinstall || pkg.scripts?.install) errors.push('install-time script is forbidden for the prebuilt package')
+if (!pkg.dsh?.bundle?.patch || !pkg.dsh?.client) errors.push('missing DSH bundle patch or client manifest')
+if (!pkg.engines?.dsh) errors.push('missing tested engines.dsh range')
+if (!readFileSync('cordis.patch.yml', 'utf8').includes(`id: ${expectedId}`)) errors.push(`patch does not preserve plugin id ${expectedId}`)
+if (pkg.private === true) warnings.push('private:true prevents public npm publish')
+if (!pkg.license || pkg.license === 'UNLICENSED') warnings.push('public distribution license needs owner review')
+
+let manifest
+try {
+  const raw = execSync('npm pack --dry-run --json --ignore-scripts', { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] })
+  const parsed = JSON.parse(raw)
+  manifest = Array.isArray(parsed) ? parsed[0] : parsed[pkg.name] ?? Object.values(parsed)[0]
+} catch (error) {
+  errors.push(`npm pack failed: ${error.stderr?.toString().trim() || error.message}`)
+}
+
+if (manifest) {
+  const names = new Set(manifest.files.map(file => file.path.replaceAll('\\', '/')))
+  for (const path of requirements[pkg.name] ?? []) if (!names.has(path)) errors.push(`missing runtime asset: ${path}`)
+  try {
+    const screenshots = JSON.parse(readFileSync('screenshots.json', 'utf8'))
+    if (!Array.isArray(screenshots) || screenshots.length < 1 || screenshots.length > 8) errors.push('screenshots.json must list 1–8 images')
+    else for (const path of screenshots) {
+      if (typeof path !== 'string' || path.startsWith('/') || path.includes('..') || !/\.(png|jpe?g|webp)$/i.test(path)) errors.push(`invalid screenshot path: ${path}`)
+      else if (!names.has(path)) errors.push(`screenshot is absent from package: ${path}`)
+    }
+  } catch (error) { errors.push(`invalid screenshots.json: ${error.message}`) }
+  const forbiddenName = /(^|\/)(?:node_modules|private|profiles|logs|\.git|\.env[^/]*|\.npmrc|credentials(?:\.json)?|secrets?)(?:\/|$)|^runtime\/|\.(?:db|sqlite(?:-wal|-shm)?|log|key|pem)$/i
+  const secret = /gh[pousr]_[A-Za-z0-9_]{30,}|(?:sk-|sk_)[A-Za-z0-9]{32,}|-----BEGIN (?:RSA|OPENSSH|EC) PRIVATE KEY-----|DEEPSEEK_API_KEY\s*[:=]\s*['"]?[A-Za-z0-9_-]{16,}/
+  for (const path of names) {
+    if (forbiddenName.test(path)) errors.push(`forbidden package path: ${path}`)
+    if (path === 'package.json') continue
+    const file = readFileSync(resolve(path))
+    if (file.length <= 2_000_000 && !file.includes(0) && secret.test(file.toString('utf8'))) errors.push(`possible credential in package file: ${path}`)
+  }
+  console.log(JSON.stringify({ name: manifest.name, version: manifest.version, files: names.size, unpackedBytes: manifest.unpackedSize, warnings }, null, 2))
+}
+if (errors.length) {
+  for (const error of errors) console.error(`ERROR ${error}`)
+  process.exitCode = 1
+}

package/scripts/symlink-security.mjs

@@ -0,0 +1,8 @@
+import {spawnSync} from 'node:child_process';
+if(process.platform!=='linux')throw Error('Run this release gate on Linux; Windows skips do not satisfy it');
+const files=['tests/audio-read.test.mjs','tests/media-read.test.mjs','tests/file-read.test.mjs','tests/outbound-media.test.mjs'];
+const result=spawnSync(process.execPath,['--test','--test-name-pattern=symlink',...files],{encoding:'utf8'});
+process.stdout.write(result.stdout??'');process.stderr.write(result.stderr??'');
+const cases=(result.stdout??'').split(/\r?\n/).filter(line=>/^(?:not )?ok \d+ - .*symlink/i.test(line));
+if(result.status!==0||cases.length!==4||cases.some(line=>!line.startsWith('ok ')||/# SKIP|# TODO/.test(line)))throw Error('All four symlink security cases must execute and pass without skips');
+console.log('RELEASE_GATE: 4 symlink safety tests executed and passed');

package/src/account-profile.js

@@ -0,0 +1,223 @@
+import { createHash } from 'node:crypto'
+import path from 'node:path'
+import { snapshotControlledImage } from './outbound-media.js'
+
+const STATUS_VALUES = new Set([10, 30, 40, 50, 60, 70])
+const MAX_SIGNATURE = 200
+const MAX_NICKNAME = 36
+
+function profileError(code) {
+  const error = new Error(code)
+  error.code = code
+  return error
+}
+
+function cleanText(value, max, code) {
+  if (typeof value !== 'string') throw profileError(code)
+  const text = value.replace(/[\u0000-\u001f\u007f]/g, '').trim()
+  if (text.length === 0 || text.length > max) throw profileError(code)
+  return text
+}
+
+function decimalId(value) {
+  const id = typeof value === 'number' && Number.isSafeInteger(value) ? String(value) : value
+  if (typeof id !== 'string' || !/^[1-9]\d{0,19}$/.test(id)) throw profileError('QQ_PROFILE_RESPONSE_INVALID')
+  return id
+}
+
+function responseInvalid() {
+  return profileError('QQ_PROFILE_RESPONSE_INVALID')
+}
+
+function profileFingerprint(scene, action, payload) {
+  return createHash('sha256')
+    .update(JSON.stringify({
+      account: scene.botId,
+      scene: scene.peerId,
+      action,
+      payload,
+    }))
+    .digest('hex')
+}
+
+export function createAccountProfile({ core, transport, authorize, ledger, sendRoot, tempRoot }) {
+  if (typeof authorize !== 'function') throw profileError('QQ_PROFILE_UNAUTHORIZED')
+  if (!transport || typeof transport.action !== 'function') throw profileError('QQ_PROFILE_UNAVAILABLE')
+
+  async function check(sessionId, action, write) {
+    let scene
+    try {
+      scene = core.authorizedScene(sessionId)
+    } catch {
+      throw profileError('QQ_PROFILE_UNAUTHORIZED')
+    }
+    if (write && scene.kind !== 'private') throw profileError('QQ_PROFILE_OWNER_REQUIRED')
+    let allowed = false
+    try {
+      allowed = await authorize({ action, write, sessionId, scene }) === true
+    } catch {
+      allowed = false
+    }
+    if (!allowed) throw profileError('QQ_PROFILE_UNAUTHORIZED')
+    return scene
+  }
+
+  async function call(action, params, write) {
+    let data
+    try {
+      data = await transport.action(action, params, 10_000)
+    } catch (error) {
+      if (!write) throw profileError('QQ_PROFILE_UNAVAILABLE')
+      if (error?.code === 'ONEBOT_REJECTED') throw profileError('QQ_PROFILE_REJECTED')
+      throw profileError('QQ_PROFILE_UNKNOWN')
+    }
+    if (data === null || data === undefined) {
+      if (write) return {}
+      throw responseInvalid()
+    }
+    if (typeof data !== 'object') throw responseInvalid()
+    return data
+  }
+
+  async function loginInfo(sessionId, write = false) {
+    const data = await call('get_login_info', {}, write)
+    return { userId: decimalId(data.user_id), nickname: typeof data.nickname === 'string' ? data.nickname.slice(0, MAX_NICKNAME) : '' }
+  }
+
+  async function strangerInfo(sessionId, userId, write = false) {
+    const data = await call('get_stranger_info', { user_id: userId, no_cache: true }, write)
+    return {
+      longNick: typeof data.long_nick === 'string' ? data.long_nick.slice(0, MAX_SIGNATURE) : '',
+      status: Number.isFinite(Number(data.status)) ? Number(data.status) : null,
+    }
+  }
+
+  async function userStatus(userId, write = false) {
+    const data = await call('nc_get_user_status', { user_id: userId }, write)
+    const status = Number(data.status)
+    const extStatus = Number(data.ext_status)
+    if (!Number.isSafeInteger(status) || !Number.isSafeInteger(extStatus)) throw responseInvalid()
+    return { status, extStatus }
+  }
+
+  async function readProfileInternal(sessionId, write = false) {
+    const login = await loginInfo(sessionId, write)
+    const stranger = await strangerInfo(sessionId, login.userId, write)
+    const online = await userStatus(login.userId, write)
+    return {
+      userId: login.userId,
+      nickname: login.nickname,
+      signature: stranger.longNick,
+      status: online.status,
+      extStatus: online.extStatus,
+    }
+  }
+
+  async function writeWithLedger(sessionId, action, payload, actionId, verify) {
+    const scene = await check(sessionId, action, true)
+    if (!ledger || typeof ledger.run !== 'function') throw profileError('QQ_PROFILE_LEDGER_REQUIRED')
+    if (typeof actionId !== 'string' || !/^[\w-]{1,100}$/.test(actionId)) throw profileError('QQ_PROFILE_ACTION_ID_INVALID')
+    const fingerprint = profileFingerprint(scene, action, payload)
+    return ledger.run({
+      actionId,
+      fingerprint,
+      action,
+      sessionId,
+      sceneKey: `${scene.botId}:${scene.kind}:${scene.peerId}`,
+      execute: async () => {
+        await call(action, payload, true)
+        try {
+          await check(sessionId, action, true)
+        } catch {
+          // The platform write already happened; do not report a clean failure.
+          throw profileError('QQ_PROFILE_UNKNOWN')
+        }
+        let profile
+        try {
+          profile = await readProfileInternal(sessionId, true)
+          if (!(await verify(profile))) throw profileError('QQ_PROFILE_UNKNOWN')
+        } catch (error) {
+          if (error?.code === 'QQ_PROFILE_UNKNOWN') throw error
+          throw profileError('QQ_PROFILE_UNKNOWN')
+        }
+        try {
+          await check(sessionId, action, true)
+        } catch {
+          throw profileError('QQ_PROFILE_UNKNOWN')
+        }
+        return profile
+      },
+    })
+  }
+
+  return Object.freeze({
+    async readProfile({ sessionId }) {
+      await check(sessionId, 'get_login_info', false)
+      const profile = await readProfileInternal(sessionId)
+      await check(sessionId, 'get_login_info', false)
+      return profile
+    },
+
+    async setSignature({ sessionId, signature, actionId }) {
+      const value = cleanText(signature, MAX_SIGNATURE, 'QQ_PROFILE_SIGNATURE_INVALID')
+      return writeWithLedger(sessionId, 'set_self_longnick', { longNick: value }, actionId,
+        profile => profile.signature === value)
+    },
+
+    async setNickname({ sessionId, nickname, actionId }) {
+      const value = cleanText(nickname, MAX_NICKNAME, 'QQ_PROFILE_NICKNAME_INVALID')
+      return writeWithLedger(sessionId, 'set_qq_profile', { nickname: value }, actionId,
+        profile => profile.nickname === value)
+    },
+
+    async setOnlineStatus({ sessionId, status, extStatus, batteryStatus, actionId }) {
+      if (!Number.isSafeInteger(status) || !STATUS_VALUES.has(status)) throw profileError('QQ_PROFILE_STATUS_INVALID')
+      if (!Number.isSafeInteger(extStatus) || extStatus < 0 || extStatus > 9999) throw profileError('QQ_PROFILE_STATUS_INVALID')
+      if (!Number.isSafeInteger(batteryStatus) || batteryStatus < 0 || batteryStatus > 100) throw profileError('QQ_PROFILE_STATUS_INVALID')
+      return writeWithLedger(sessionId, 'set_online_status', {
+        status, ext_status: extStatus, battery_status: batteryStatus,
+      }, actionId, profile => profile.status === status && profile.extStatus === extStatus)
+    },
+
+    async setAvatar({ sessionId, path: relativePath, actionId }) {
+      if (typeof sendRoot !== 'string' || !path.isAbsolute(sendRoot)) {
+        throw profileError('QQ_PROFILE_AVATAR_ROOT_INVALID')
+      }
+      const scene = await check(sessionId, 'set_qq_avatar', true)
+      if (!ledger || typeof ledger.run !== 'function') throw profileError('QQ_PROFILE_LEDGER_REQUIRED')
+      if (typeof actionId !== 'string' || !/^[\w-]{1,100}$/.test(actionId)) throw profileError('QQ_PROFILE_ACTION_ID_INVALID')
+
+      let snapshot
+      try {
+        snapshot = await snapshotControlledImage({ sendRoot, relativePath, tempRoot })
+      } catch {
+        throw profileError('QQ_PROFILE_AVATAR_INVALID')
+      }
+      const fingerprint = profileFingerprint(scene, 'set_qq_avatar', {
+        sha256: snapshot.sha256,
+        mediaType: snapshot.mediaType,
+      })
+      try {
+        return await ledger.run({
+          actionId,
+          fingerprint,
+          action: 'set_qq_avatar',
+          sessionId,
+          sceneKey: `${scene.botId}:${scene.kind}:${scene.peerId}`,
+          execute: async () => {
+            await call('set_qq_avatar', { file: snapshot.path }, true)
+            try {
+              await check(sessionId, 'set_qq_avatar', true)
+            } catch {
+              // The platform accepted the write; a later revocation is unknown.
+              throw profileError('QQ_PROFILE_UNKNOWN')
+            }
+            return { status: 'confirmed', mediaType: snapshot.mediaType, bytes: snapshot.bytes }
+          },
+        })
+      } finally {
+        await snapshot.cleanup()
+      }
+    },
+  })
+}