dsh-plugin-discourse 1.0.0 → 1.1.0

package/locale/en.json

@@ -1,6 +1,6 @@
 {
   "meta": {
     "title": "Discourse",
-    "description": "Search, read, post, moderate, and administer a Discourse forum."
+    "description": "Search, read, post, moderate, and administer a Discourse forum, with browser sign-in."
   }
 }

package/locale/zh.json

@@ -1,6 +1,6 @@
 {
   "meta": {
     "title": "Discourse 论坛",
-    "description": "搜索、阅读、发帖、审核与管理 Discourse 论坛。"
+    "description": "搜索、阅读、发帖、审核与管理 Discourse 论坛，支持浏览器授权登录。"
   }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-plugin-discourse",
-  "version": "1.0.0",
-  "description": "Discourse administration and agent tools for the DeepSeek Harness: 16 tools for reading, posting, moderating, and administering a Discourse forum.",
+  "version": "1.1.0",
+  "description": "Discourse administration and agent tools for the DeepSeek Harness: 17 tools for reading, posting, moderating, administering, and signing in to a Discourse forum through the browser.",
   "license": "MIT",
   "author": "AkarinLiu",
   "type": "module",
@@ -30,6 +30,13 @@
     "registry": "https://registry.npmjs.org",
     "access": "public"
   },
+  "scripts": {
+    "test": "node scripts/smoke.mjs && node scripts/login-test.mjs",
+    "test:login": "node scripts/login-test.mjs",
+    "verify": "node scripts/verify-package.mjs",
+    "doctor": "node scripts/doctor.mjs",
+    "prepack": "node scripts/smoke.mjs && node scripts/login-test.mjs"
+  },
   "exports": {
     ".": "./index.js",
     "./locale/*.json": "./locale/*.json",

package/scripts/doctor.mjs

@@ -0,0 +1,159 @@
+#!/usr/bin/env node
+/**
+ * Diagnose (and with --fix, remove) the Windows install trap where a stale
+ * directory junction for this bundle blocks a registry install:
+ *
+ *   [ERR_PNPM_EPERM] [importPackage ...\node_modules\dsh-plugin-discourse]
+ *   EPERM: operation not permitted, rename '..._tmp_...' -> '...dsh-plugin-discourse'
+ *
+ * A local-clone install (dsh plugin add ./dsh-plugin-discourse) creates that
+ * junction. pnpm's hoisted linker does not always record or prune it, so a
+ * later npm install cannot replace it. Removing the junction removes only the
+ * link; the checkout it points at is left untouched.
+ *
+ *   node scripts/doctor.mjs --profile desktop
+ *   node scripts/doctor.mjs --profile desktop --fix
+ */
+
+import { readFileSync, existsSync, lstatSync, realpathSync, unlinkSync, rmdirSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { basename, dirname, join, resolve } from 'node:path'
+
+const PACKAGE = 'dsh-plugin-discourse'
+
+const argv = process.argv.slice(2)
+const profileIndex = argv.indexOf('--profile')
+const profile = profileIndex >= 0 ? argv[profileIndex + 1] : 'desktop'
+const fix = argv.includes('--fix')
+
+if (profileIndex >= 0 && (profile === undefined || profile.startsWith('--'))) {
+  console.error('usage: node scripts/doctor.mjs [--profile <name>] [--fix]')
+  process.exit(2)
+}
+
+const dshHome = process.env.DSH_HOME ?? join(homedir(), '.dsh')
+const profileDir = join(dshHome, 'profiles', profile)
+const manifestPath = join(profileDir, 'package.json')
+const linkPath = join(profileDir, 'node_modules', PACKAGE)
+
+if (!existsSync(manifestPath)) {
+  console.error(`no DSH profile at ${profileDir}: open DeepSeek Harness once for that profile, then retry`)
+  process.exit(2)
+}
+
+/** Read JSON that a Windows editor or PowerShell may have prefixed with a BOM. */
+function readJson(path) {
+  return JSON.parse(readFileSync(path, 'utf8').replace(/^\uFEFF/, ''))
+}
+
+/** The spec the profile records for this bundle, when it records one. */
+function dependencySpec() {
+  try {
+    const manifest = readJson(manifestPath)
+    for (const field of ['dependencies', 'devDependencies', 'optionalDependencies']) {
+      const spec = manifest?.[field]?.[PACKAGE]
+      if (typeof spec === 'string' && spec.length > 0) return spec
+    }
+  } catch (error) {
+    console.error(`could not read ${manifestPath}: ${error.message}`)
+    process.exit(2)
+  }
+  return undefined
+}
+
+/**
+ * Inspect one node_modules entry. A junction (or symlink) resolves to a
+ * different path than the lexical entry; a normal package directory does not.
+ */
+function inspectEntry(path) {
+  let stats
+  try {
+    stats = lstatSync(path)
+  } catch {
+    return undefined
+  }
+  let target
+  try {
+    target = realpathSync.native(path)
+  } catch {
+    target = undefined
+  }
+  let expected = resolve(path)
+  try {
+    expected = join(realpathSync.native(dirname(path)), basename(path))
+  } catch {
+    // The parent is always readable when lstat succeeded; keep the lexical form.
+  }
+  const same = target !== undefined && (process.platform === 'win32'
+    ? target.toLowerCase() === expected.toLowerCase()
+    : target === expected)
+  return { target, isLink: stats.isSymbolicLink() || !same }
+}
+
+/** Remove a link without ever recursing into its target. */
+function removeLink(path) {
+  try {
+    unlinkSync(path)
+    return
+  } catch (error) {
+    if (!['EPERM', 'EISDIR', 'ENOTDIR', 'EACCES'].includes(error.code)) throw error
+  }
+  // On Windows rmdir deletes the junction's reparse point, not the target.
+  rmdirSync(path)
+}
+
+const entry = inspectEntry(linkPath)
+
+if (entry === undefined) {
+  console.log(`ok: no stale ${PACKAGE} entry in ${profileDir}; run "dsh plugin --profile ${profile} add ${PACKAGE}" to install it`)
+  process.exit(0)
+}
+
+if (!entry.isLink) {
+  if (existsSync(join(linkPath, 'package.json'))) {
+    console.log(`ok: ${PACKAGE} is installed as a normal directory in ${profileDir}`)
+    process.exit(0)
+  }
+  console.error(`${linkPath} exists but is not a package and not a link; inspect it by hand`)
+  process.exit(1)
+}
+
+const spec = dependencySpec()
+const target = entry.target ?? '(unresolvable)'
+const localSpec = spec !== undefined && (spec.startsWith('link:') || spec.startsWith('file:'))
+
+console.log(`found a directory link for ${PACKAGE}:`)
+console.log(`  link:       ${linkPath}`)
+console.log(`  target:     ${target}`)
+console.log(`  dependency: ${spec ?? '(not recorded)'}`)
+console.log(localSpec
+  ? 'The profile records a local spec, so this link is expected while the checkout is installed directly.'
+  : 'The profile records a registry spec, so this link is a leftover from an earlier local install.')
+
+if (!fix) {
+  if (localSpec) {
+    console.log('ok: this is a local development install; rerun with --fix only when switching the profile to the npm package.')
+    process.exit(0)
+  }
+  console.error('stale link blocks "pnpm install"; re-run with --fix to remove the link only, then install again:')
+  console.error(`  node scripts/doctor.mjs --profile ${profile} --fix`)
+  console.error(`  dsh plugin --profile ${profile} add ${PACKAGE}`)
+  process.exit(1)
+}
+
+try {
+  removeLink(linkPath)
+} catch (error) {
+  console.error(`could not remove ${linkPath}: ${error.message}`)
+  console.error('close DeepSeek Harness, then retry, or delete the junction in Explorer.')
+  process.exit(1)
+}
+
+if (existsSync(linkPath) || inspectEntry(linkPath) !== undefined) {
+  console.error(`${linkPath} still exists after removal`)
+  process.exit(1)
+}
+
+console.log(`removed the link; ${target === '(unresolvable)' ? 'the target' : target} was left untouched.`)
+console.log('now install the bundle:')
+console.log(`  dsh plugin --profile ${profile} add ${PACKAGE}`)

package/scripts/login-test.mjs

@@ -0,0 +1,272 @@
+#!/usr/bin/env node
+/**
+ * Offline end-to-end test for the browser sign-in tool.
+ *
+ * A stub credential store, a stub authorization seam, and a stub forum exercise
+ * the real `apply()` path: start the classic authorization page, complete it
+ * with an encrypted payload, read the signed-in status, cancel a pending
+ * attempt, and sign out; then repeat through the device-code path. The test
+ * never reaches the network and never prints the user API key.
+ */
+
+import { constants, publicEncrypt } from 'node:crypto'
+import { apply } from '../index.js'
+
+// The plugin also reads these from the environment; keep the test deterministic.
+delete process.env.DISCOURSE_API_KEY
+delete process.env.DISCOURSE_API_USERNAME
+
+const problems = []
+const store = new Map()
+const flows = new Map()
+const requests = []
+let activeController
+let deviceSupported = false
+let deviceAuth
+let devicePolls = 0
+const DEVICE_KEY = 'device-key-456'
+
+/** Build a JSON response without a network. */
+function json(body, status = 200) {
+  return new Response(JSON.stringify(body), { status, headers: { 'content-type': 'application/json' } })
+}
+
+const credentials = {
+  async readRecord(key) {
+    return store.get(key)
+  },
+  async describeRecord(key) {
+    const record = store.get(key)
+    return { configured: record !== undefined, kind: record?.kind, writable: true }
+  },
+  async modifyRecord(key, mutate) {
+    const next = await mutate(store.get(key))
+    if (next === undefined) return store.get(key)
+    store.set(key, next)
+    return next
+  },
+  async deleteRecord(key) {
+    store.delete(key)
+  },
+}
+
+const authorization = {
+  registerFlow(flow) {
+    flows.set(flow.key, flow)
+    return () => {
+      flows.delete(flow.key)
+      this.cancel(flow.key)
+    }
+  },
+  cancel() {
+    activeController?.abort()
+  },
+  async begin({ key, signal, interaction }) {
+    const flow = flows.get(key)
+    if (flow === undefined) {
+      const error = new Error(`no authorization flow for ${key}`)
+      error.code = 'NO_FLOW'
+      throw error
+    }
+    activeController = new AbortController()
+    const combined = signal ?? activeController.signal
+    const session = {
+      method: flow.methods[0].id,
+      signal: combined,
+      notify: (notice) => interaction.notify(notice),
+      prompt: (question) => interaction.prompt(question),
+      commit: async (record) => {
+        await credentials.modifyRecord(key, () => Promise.resolve(record))
+      },
+    }
+    try {
+      await flow.run(session)
+      return { status: 'authorized' }
+    } catch (error) {
+      if (combined.aborted) return { status: 'cancelled' }
+      throw error
+    }
+  },
+}
+
+globalThis.fetch = async (input, init = {}) => {
+  const url = new URL(String(input))
+  const headers = new Headers(init.headers)
+  requests.push({ path: url.pathname, method: init.method ?? 'GET', headers })
+  if (url.pathname === '/user-api-key/device.json') {
+    if (!deviceSupported) {
+      // Pretend this is a forum older than the device authorization flow.
+      return json({ errors: ['not found'] }, 404)
+    }
+    const body = JSON.parse(init.body)
+    deviceAuth = { publicKey: body.public_key, nonce: body.nonce }
+    devicePolls = 0
+    return json({
+      device_code: 'a'.repeat(64),
+      user_code: 'ABCD-EFGH',
+      verification_uri: 'https://forum.test/user-api-key/activate',
+      verification_uri_with_request: 'https://forum.test/user-api-key/activate?request=abcd1234',
+      expires_in: 600,
+      interval: 1,
+    })
+  }
+  if (url.pathname === '/user-api-key/device/poll.json') {
+    if (!deviceSupported) return json({ errors: ['not found'] }, 404)
+    devicePolls += 1
+    if (devicePolls === 1) return json({ status: 'authorization_pending' })
+    const plaintext = JSON.stringify({ key: DEVICE_KEY, nonce: deviceAuth.nonce, push: false, api: 4 })
+    const payload = publicEncrypt(
+      { key: deviceAuth.publicKey, padding: constants.RSA_PKCS1_OAEP_PADDING, oaepHash: 'sha1' },
+      Buffer.from(plaintext, 'utf8'),
+    ).toString('base64')
+    return json({ status: 'authorized', payload })
+  }
+  if (url.pathname === '/session/current.json') {
+    const key = headers.get('user-api-key')
+    if (key === 'user-key-123') return json({ current_user: { id: 7, username: 'tester' } })
+    if (key === DEVICE_KEY) return json({ current_user: { id: 8, username: 'device-tester' } })
+    return json({ errors: ['bad key'] }, 403)
+  }
+  if (url.pathname === '/user-api-key/revoke.json') {
+    const key = headers.get('user-api-key')
+    if (key === 'user-key-123' || key === DEVICE_KEY) return json({ success: 'OK' })
+    return json({ errors: ['bad key'] }, 403)
+  }
+  return json({ errors: [`unexpected ${url.pathname}`] }, 500)
+}
+
+const registry = new Map()
+const ctx = {
+  tools: {
+    register(tool) {
+      registry.set(tool.name, tool)
+      return () => registry.delete(tool.name)
+    },
+  },
+  effect(callback) {
+    const dispose = callback()
+    return () => {
+      if (typeof dispose === 'function') dispose()
+    }
+  },
+  get(name) {
+    if (name === 'credentials') return credentials
+    if (name === 'authorization') return authorization
+    return undefined
+  },
+  inject(_deps, callback) {
+    return callback(ctx)
+  },
+}
+
+apply(ctx, {
+  baseUrl: 'https://forum.test',
+  apiKey: '',
+  authMode: 'auto',
+  loginScopes: 'read,write,session_info',
+  loginTimeoutMs: 60000,
+})
+
+const login = registry.get('discourse_login')
+if (login === undefined) problems.push('discourse_login was not registered')
+
+if (problems.length === 0) {
+  const started = await login.execute({ action: 'start' }, {})
+  if (started.signedIn !== false) problems.push('start should report signed out')
+  if (started.attempt?.status !== 'pending') problems.push(`start should report a pending attempt, got ${started.attempt?.status}`)
+  if (started.attempt?.mode !== 'manual') problems.push(`classic fallback should use manual mode, got ${started.attempt?.mode}`)
+  if (typeof started.attempt?.url !== 'string') problems.push('start did not return an authorization URL')
+
+  const startView = login.output.render({ action: 'start' }, started).map((block) => block.text).join('\n')
+  if (!startView.includes(started.attempt.url)) problems.push('start render did not include the authorization URL')
+  if (!startView.includes('discourse_login')) problems.push('start render did not explain the next status call')
+
+  const url = new URL(started.attempt.url)
+  if (!url.pathname.endsWith('/user-api-key/new')) problems.push(`unexpected authorization path ${url.pathname}`)
+  if (url.searchParams.get('client_id') !== 'dsh-plugin-discourse') problems.push('authorization URL lost the client id')
+  if (url.searchParams.has('padding')) problems.push('classic fallback should let the forum use its default padding')
+  const publicKey = url.searchParams.get('public_key')
+  const nonce = url.searchParams.get('nonce')
+  if (typeof publicKey !== 'string' || !publicKey.includes('BEGIN PUBLIC KEY')) problems.push('authorization URL has no PEM public key')
+  if (typeof nonce !== 'string' || nonce.length < 32) problems.push('authorization URL has no nonce')
+
+  const plaintext = JSON.stringify({ key: 'user-key-123', nonce, push: false, api: 4 })
+  // The classic page omits `padding`, so Discourse encrypts with PKCS#1 there;
+  // the device path uses OAEP. Both decryption branches are covered here.
+  const payload = publicEncrypt(
+    { key: publicKey, padding: constants.RSA_PKCS1_PADDING },
+    Buffer.from(plaintext, 'utf8'),
+  ).toString('base64')
+
+  const completed = await login.execute({ action: 'complete', payload }, {})
+  if (completed.signedIn !== true) problems.push('complete should report signed in')
+  if (completed.session?.username !== 'tester') problems.push(`complete should read the account, got ${JSON.stringify(completed.session)}`)
+  if (completed.session?.scopes?.join(',') !== 'read,write,session_info') problems.push('session scopes did not round-trip')
+  if (JSON.stringify(completed).includes('user-key-123')) problems.push('complete leaked the user API key')
+
+  const status = await login.execute({ action: 'status' }, {})
+  if (status.signedIn !== true) problems.push('status should report signed in after complete')
+  if (status.activeSource !== 'user-session') problems.push(`status source should be user-session, got ${status.activeSource}`)
+  if (JSON.stringify(status).includes('user-key-123')) problems.push('status leaked the user API key')
+
+  const record = store.get('discourse/session')
+  if (record?.kind !== 'grant') problems.push('the session record is not a grant')
+  if (record?.payload?.baseUrl !== 'https://forum.test') problems.push('the session record has the wrong forum')
+  if (record?.payload?.clientId !== 'dsh-plugin-discourse') problems.push('the session record has the wrong client id')
+
+  const rendered = login.output.render({ action: 'status' }, status).map((block) => block.text).join('\n')
+  if (!rendered.includes('@tester')) problems.push(`render did not name the account: ${rendered}`)
+  if (rendered.includes('user-key-123')) problems.push('render leaked the user API key')
+
+  const signedOut = await login.execute({ action: 'logout' }, {})
+  if (signedOut.signedOut !== true) problems.push('logout should report signed out')
+  if (signedOut.revoked !== true) problems.push('logout should revoke the forum key')
+  if (store.size !== 0) problems.push('logout did not delete the local session record')
+
+  const after = await login.execute({ action: 'status' }, {})
+  if (after.signedIn !== false) problems.push('status should report signed out after logout')
+
+  const revoke = requests.find((request) => request.path === '/user-api-key/revoke.json')
+  if (revoke === undefined) problems.push('logout did not call the revoke endpoint')
+  else if (revoke.headers.get('user-api-key') !== 'user-key-123') problems.push('logout did not authenticate with the user API key')
+
+  const restarted = await login.execute({ action: 'start', mode: 'manual' }, {})
+  if (restarted.attempt?.status !== 'pending') problems.push('manual restart should be pending before cancel')
+  const cancelled = await login.execute({ action: 'cancel' }, {})
+  if (cancelled.cancelled !== true) problems.push('cancel should report that an attempt was cancelled')
+  if (cancelled.signedIn !== false) problems.push('cancel should leave the session signed out')
+  if (cancelled.attempt !== undefined) problems.push('cancel should clear the pending attempt')
+}
+
+// The device flow is the preferred path on a current forum: request a code,
+// poll while pending, then accept the encrypted payload.
+if (problems.length === 0) {
+  deviceSupported = true
+  const started = await login.execute({ action: 'start', mode: 'device' }, {})
+  if (started.signedIn !== false) problems.push('device start should report signed out')
+  if (started.attempt?.status !== 'pending') problems.push(`device start should report pending, got ${started.attempt?.status}`)
+  if (started.attempt?.mode !== 'device') problems.push(`device start should report device mode, got ${started.attempt?.mode}`)
+  if (started.attempt?.userCode !== 'ABCD-EFGH') problems.push(`device start lost the user code: ${started.attempt?.userCode}`)
+  if (!String(started.attempt?.url).includes('/user-api-key/activate')) problems.push('device start did not return the activation URL')
+
+  const waited = await login.execute({ action: 'status', waitSeconds: 10 }, {})
+  if (waited.signedIn !== true) problems.push('device status wait should report signed in')
+  if (waited.session?.username !== 'device-tester') problems.push(`device sign-in should read the account, got ${JSON.stringify(waited.session)}`)
+  if (JSON.stringify(waited).includes(DEVICE_KEY)) problems.push('device status leaked the user API key')
+  if (devicePolls < 2) problems.push(`device flow should poll at least twice, polled ${devicePolls}`)
+
+  const record = store.get('discourse/session')
+  if (record?.payload?.source !== 'device') problems.push(`device session source should be device, got ${record?.payload?.source}`)
+
+  const signedOut = await login.execute({ action: 'logout' }, {})
+  if (signedOut.revoked !== true) problems.push('device logout should revoke the forum key')
+  if (store.size !== 0) problems.push('device logout did not delete the local session record')
+}
+
+if (problems.length > 0) {
+  console.error('browser login test failed:')
+  for (const problem of problems) console.error(`  - ${problem}`)
+  process.exit(1)
+}
+
+console.log('ok: browser login starts, completes, reports, and revokes offline')

package/scripts/smoke.mjs

@@ -30,6 +30,12 @@ const ctx = {
       if (typeof dispose === 'function') dispose()
     }
   },
+  get() {
+    return undefined
+  },
+  inject(_deps, callback) {
+    return callback(ctx)
+  },
 }
 
 apply(ctx, { baseUrl, readOnly: true, maxItems: 5 })
@@ -51,6 +57,7 @@ const expected = [
   'discourse_moderate_user',
   'discourse_site_settings',
   'discourse_admin_stats',
+  'discourse_login',
 ]
 
 for (const name of expected) {
@@ -74,6 +81,29 @@ for (const [name, tool] of registry) {
   }
 }
 
+// The login tool must report a signed-out state without the credential store,
+// and it must not expose a key it never stored.
+try {
+  const value = await registry.get('discourse_login').execute({ action: 'status' }, {})
+  if (value?.signedIn !== false) problems.push('discourse_login status should report signed out offline')
+  if (value?.storageAvailable !== false) problems.push('discourse_login status should report missing credential storage offline')
+  if (JSON.stringify(value).includes('"key"')) problems.push('discourse_login status leaked a key field')
+} catch (error) {
+  problems.push(`discourse_login status failed offline: ${error.message}`)
+}
+
+// A malformed forum URL must fail at activation with a usable diagnostic,
+// before any tool is registered.
+try {
+  apply({
+    tools: { register() { problems.push('invalid baseUrl registered a tool') } },
+    effect(callback) { callback() },
+  }, { baseUrl: 'ftp://forum.example.com' })
+  problems.push('invalid baseUrl was accepted')
+} catch (error) {
+  if (!/http\(s\) URL/.test(error.message)) problems.push(`invalid baseUrl diagnostic is unhelpful: ${error.message}`)
+}
+
 const describe = (value) => {
   const rendered = value.map((block) => block.text ?? `[${block.type}]`).join('\n')
   return rendered.length > 700 ? `${rendered.slice(0, 700)}…` : rendered

package/scripts/verify-package.mjs

@@ -0,0 +1,155 @@
+#!/usr/bin/env node
+/**
+ * Verify that the published tarball contains every runtime asset the DeepSeek
+ * Harness needs: the Host entry, the bundle patch, both locales, the icon, and
+ * the manifest. Run before a release or from CI.
+ *
+ *   node scripts/verify-package.mjs
+ */
+
+import { spawnSync } from 'node:child_process'
+import { closeSync, existsSync, mkdtempSync, openSync, readFileSync, rmSync, statSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { dirname, join, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), '..')
+/** Read JSON that may carry a UTF-8 BOM from a Windows editor. */
+const readJson = (path) => JSON.parse(readFileSync(path, 'utf8').replace(/^\uFEFF/, ''))
+const manifest = readJson(join(root, 'package.json'))
+const problems = []
+
+/** Record one packaging violation. */
+function check(condition, message) {
+  if (!condition) problems.push(message)
+}
+
+// --- Manifest --------------------------------------------------------------
+
+check(manifest.private !== true, 'package.json must not set "private": true, or npm refuses to publish it')
+check(typeof manifest.name === 'string' && manifest.name.length > 0, 'package.json needs a name')
+check(/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(manifest.version ?? ''), `package.json version is not semver: ${JSON.stringify(manifest.version)}`)
+check(manifest.type === 'module', 'package.json must stay "type": "module"')
+check(manifest.publishConfig?.access === 'public', 'publishConfig.access must be "public"')
+check(manifest.publishConfig?.registry === 'https://registry.npmjs.org', 'publishConfig.registry must name npmjs.com')
+check(manifest.engines?.node === '>=20', 'engines.node must stay ">=20"')
+
+const patch = manifest.dsh?.bundle?.patch
+check(typeof patch === 'string' && patch.length > 0, 'package.json must declare dsh.bundle.patch')
+if (typeof patch === 'string') {
+  check(existsSync(join(root, patch)), `dsh.bundle.patch points at a missing file: ${patch}`)
+}
+
+for (const [subpath, target] of Object.entries(manifest.exports ?? {})) {
+  if (typeof target !== 'string' || target.includes('*')) continue
+  check(existsSync(join(root, target)), `exports["${subpath}"] points at a missing file: ${target}`)
+}
+
+// --- Local assets ----------------------------------------------------------
+
+const required = [
+  'index.js',
+  'cordis.patch.yml',
+  'README.md',
+  'LICENSE',
+  'locale/en.json',
+  'locale/zh.json',
+  'icon.svg',
+  'scripts/smoke.mjs',
+  'scripts/login-test.mjs',
+  'scripts/doctor.mjs',
+  'scripts/verify-package.mjs',
+]
+for (const relative of required) check(existsSync(join(root, relative)), `missing required file: ${relative}`)
+
+for (const locale of ['locale/en.json', 'locale/zh.json']) {
+  const file = join(root, locale)
+  if (!existsSync(file)) continue
+  try {
+    const value = readJson(file)
+    check(typeof value?.meta?.title === 'string' && value.meta.title.length > 0, `${locale} needs meta.title`)
+    check(typeof value?.meta?.description === 'string' && value.meta.description.length > 0, `${locale} needs meta.description`)
+  } catch (error) {
+    problems.push(`${locale} is not valid JSON: ${error.message}`)
+  }
+}
+
+const icon = join(root, 'icon.svg')
+if (existsSync(icon)) {
+  const size = statSync(icon).size
+  check(size > 0 && size <= 256 * 1024, `icon.svg must be between 1 byte and 256 KiB, got ${size} bytes`)
+  check(readFileSync(icon, 'utf8').includes('<svg'), 'icon.svg does not look like an SVG document')
+}
+
+// --- Packed file list ------------------------------------------------------
+
+// Run npm with its stdout attached to a real file descriptor instead of a pipe:
+// on Windows the Harness sandbox denies piped stdio, and a pipe cannot deadlock
+// a large pack listing when it is a file handle.
+/** Locate npm's JavaScript entry so it can run without a command shell. */
+function findNpmCli() {
+  const candidates = []
+  if (typeof process.env.npm_execpath === 'string') candidates.push(process.env.npm_execpath)
+  const nodeDir = dirname(process.execPath)
+  candidates.push(
+    join(nodeDir, 'node_modules', 'npm', 'bin', 'npm-cli.js'),
+    join(nodeDir, '..', 'lib', 'node_modules', 'npm', 'bin', 'npm-cli.js'),
+    join(nodeDir, '..', 'libexec', 'lib', 'node_modules', 'npm', 'bin', 'npm-cli.js'),
+  )
+  return candidates.find((candidate) => /npm-cli\.js$/i.test(candidate) && existsSync(candidate))
+}
+
+const npmCli = findNpmCli()
+const useNpmCli = npmCli !== undefined
+const command = useNpmCli ? process.execPath : process.platform === 'win32' ? 'npm.cmd' : 'npm'
+const args = [...(useNpmCli ? [npmCli] : []), 'pack', '--dry-run', '--json', '--ignore-scripts']
+const tempDir = mkdtempSync(join(tmpdir(), 'dsh-plugin-package-'))
+const packFile = join(tempDir, 'pack.json')
+let packOutput
+let fd
+try {
+  fd = openSync(packFile, 'w')
+  const result = spawnSync(command, args, {
+    cwd: root,
+    // Keep npm's cache inside this throwaway directory: the Harness sandbox
+    // cannot write the user-level cache, and CI should not depend on it either.
+    env: { ...process.env, npm_config_cache: join(tempDir, 'npm-cache') },
+    stdio: ['ignore', fd, 'inherit'],
+    shell: !useNpmCli && process.platform === 'win32',
+  })
+  closeSync(fd)
+  fd = undefined
+  if (result.error) problems.push(`npm pack failed: ${result.error.message}`)
+  else if (result.status !== 0) problems.push(`npm pack exited with status ${String(result.status)}`)
+  else packOutput = readFileSync(packFile, 'utf8')
+} finally {
+  if (fd !== undefined) closeSync(fd)
+  rmSync(tempDir, { recursive: true, force: true })
+}
+
+let packed = []
+if (packOutput) {
+  try {
+    const [info] = JSON.parse(packOutput)
+    packed = Array.isArray(info?.files) ? info.files.map((file) => file.path) : []
+  } catch (error) {
+    problems.push(`could not parse npm pack --json output: ${error.message}`)
+  }
+}
+
+if (packed.length > 0) {
+  const present = new Set(packed)
+  for (const relative of required) {
+    check(present.has(relative), `the packed tarball omits ${relative}; add it to package.json "files"`)
+  }
+  const forbidden = packed.filter((path) => path.startsWith('node_modules/') || path.startsWith('.git/') || path.includes('.tmp') || path.endsWith('.log'))
+  check(forbidden.length === 0, `the packed tarball contains development files: ${forbidden.join(', ')}`)
+}
+
+if (problems.length > 0) {
+  console.error('package verification failed:')
+  for (const problem of problems) console.error(`  - ${problem}`)
+  process.exit(1)
+}
+
+console.log(`ok: ${manifest.name}@${manifest.version} packs ${packed.length} files with every required asset`)