dsh-cds-theme 0.0.0-stage → 0.1.1

package/cordis.patch.yml

@@ -0,0 +1,4 @@
+# dsh bundle patch: inserts this plugin into a profile's layer stack.
+- insert:
+    - id: dsh-cds-theme
+      name: 'dsh-cds-theme'

package/icon.svg

@@ -0,0 +1,7 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 36 36" width="36" height="36" role="img" aria-label="Claude Design System theme">
+  <title>Claude Design System theme</title>
+  <!-- Two offset surfaces: the CDS layering idea, read as a silhouette at 36px. -->
+  <rect x="5.5" y="7.5" width="15" height="15" rx="4.5" fill="#8f8880" fill-opacity="0.45"/>
+  <rect x="15.5" y="13.5" width="15" height="15" rx="4.5" fill="#d97757"/>
+  <circle cx="23" cy="21" r="2.6" fill="#ffffff" fill-opacity="0.9"/>
+</svg>

package/lib/index.js

@@ -0,0 +1,79 @@
+/**
+ * dsh-cds-theme Host half.
+ *
+ * The theme itself is a pure browser concern: every token and rule it owns is
+ * applied by the Client half. This Host entry exists because a bundle patch
+ * inserts a Loader row, and that row resolves the package's main entry.
+ *
+ * ONE SEAM, owned by the Host: a `webserver/index-inject` global carrying the
+ * absolute `file://` fonts base, computed here from `import.meta.url` so the
+ * committed client artifact carries no path.
+ *
+ * AND ONE ROUTE, also owned by the Host: the long-paste store
+ * (`paste-route.js`). A long paste must become a real file in the Session
+ * workspace before the composer can render it as an `@path` reference chip,
+ * and only the Host can write files — the browser cannot. The route lives in
+ * its own module, with its own fence and its own tests; this entry calls its
+ * installer and nothing else.
+ *
+ * NO FONT ROUTE, AND THAT IS DELIBERATE. This plugin used to register six
+ * `webServer` routes serving `/dsh-cds-theme/fonts/<file>`. They are gone
+ * because **the branch that would use them cannot be built**:
+ *
+ *   - `client/src/font-assets.js` imports the six woff2 binaries, and
+ *     `tools/build-client.mjs` sets `loader: { '.woff2': 'dataurl' }`, so every
+ *     `@font-face` `src` in the shipped artifact is an inlined `data:` URL.
+ *     Verified against the built bundle: six `data:font/woff2` URLs and zero
+ *     route URLs in the very CSS the app injects.
+ *   - `fontSourcesFor()` only falls back to the route when a face is NOT in the
+ *     inline table. That happens only in a plain Node ESM run (the unit tests),
+ *     where `.woff2` cannot be imported — and a Node run serves no HTTP fonts.
+ *   - A build that LACKS the binaries does not produce a route-based bundle; it
+ *     fails outright (`esbuild` cannot resolve the import), as verified. So there
+ *     is no shipped configuration in which the route is the live path.
+ *   - And the route could not have served the desktop shell anyway: that
+ *     document's origin is `dsh-app://app`, where a route-relative URL resolves
+ *     into the app protocol handler and 404s.
+ *
+ * Keeping six dead HTTP routes alive would be pure attack surface for zero
+ * rendered glyphs. The `file://` global stays because it is the fallback the
+ * source-run path uses.
+ *
+ * The seam does not start anything at import time, and it lives in a plain
+ * Cordis event listener the carrier owns.
+ */
+
+import path from 'node:path'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+
+import { PASTE_PATH, installPasteRoute } from './paste-route.js'
+
+const FONTS_DIR = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'fonts')
+
+/** Mirrors `FONT_BASE_GLOBAL` in `client/src/fonts.js`. */
+export const FONT_BASE_GLOBAL = '__CDS_THEME_FONT_BASE__'
+
+/** Absolute `file://` base of the shipped fonts, with a trailing slash. */
+export const FONT_BASE_URL = pathToFileURL(FONTS_DIR).href + '/'
+
+export { PASTE_PATH }
+
+export const name = 'dsh-cds-theme'
+
+/**
+ * Publish the local fonts base into the document, and mount the paste store.
+ *
+ * The listener needs no service: it is a plain Cordis event the carrier fires
+ * while rendering the page. The paste route needs a web server and degrades to
+ * "long pastes stay plain text" when the composition has none.
+ */
+export function apply(ctx) {
+  ctx.on('webserver/index-inject', (table) => {
+    table.push({
+      kind: 'global',
+      name: FONT_BASE_GLOBAL,
+      value: FONT_BASE_URL,
+    })
+  })
+  installPasteRoute(ctx)
+}

package/lib/paste-route.js

@@ -0,0 +1,333 @@
+/**
+ * Host route: turn a pasted long text into a real file under the session
+ * workspace, and answer with the `@relative` mention the composer should carry.
+ *
+ * WHY A ROUTE. The renderer cannot write files (`ctx.fs` is a Host service; the
+ * desktop shell exposes no filesystem bridge to the page). A same-origin POST is
+ * the smallest Host seam that also works in both supported surfaces: the plain
+ * Web GUI document (`http://127.0.0.1:<port>`, same origin) and the Desktop
+ * shell (`dsh-app://app`, whose protocol handler forwards every non-asset path
+ * to the Host's own listener, see `lib/main.js` `forwardWebRequest`).
+ *
+ * THE FENCE. This route writes to disk, so it is reachable only by our own
+ * client: the listener's own authority is the reference, `sec-fetch-site` and
+ * `origin` must be absent or same-origin when present (the Desktop forwarder
+ * strips both, which is why they are optional rather than required), and a
+ * custom non-safelisted header must be present — no `<img>`, `<script>`,
+ * `<form>`, navigation, or cross-origin `fetch` can set one without a CORS
+ * preflight this server never answers. The same fence ships in
+ * `plugins/system-fonts/lib/font-route.js` and `plugins/usage-stats`.
+ *
+ * THE WORKSPACE. The Client sends only a Session id; the Host resolves the
+ * absolute workspace itself (`sessions` for a live Session,
+ * `sessionController.inspect` for a persisted one) and writes under
+ * `<cwd>/.dsh-paste/`. A browser-supplied path never reaches `fs`.
+ */
+
+import { PASTE_DIR, MAX_PASTE_BYTES, writePasteFile, formatPasteMention } from './paste-store.js'
+
+/** Route the client POSTs one converted paste to. */
+export const PASTE_PATH = '/dsh-cds-theme/paste'
+
+/** The marker every legitimate request carries (must match `client/src/paste.js`). */
+export const MARKER_HEADER = 'x-dsh-cds-theme'
+export const MARKER_VALUE = '1'
+
+/** Refuse a request body larger than this (JSON envelope included). */
+export const MAX_BODY_BYTES = MAX_PASTE_BYTES + 64 * 1024
+
+function sendJson(response, status, body) {
+  const text = JSON.stringify(body)
+  response.writeHead(status, {
+    'content-type': 'application/json; charset=utf-8',
+    'content-length': Buffer.byteLength(text),
+    'cache-control': 'no-store',
+    'x-content-type-options': 'nosniff',
+  })
+  response.end(text)
+}
+
+// ------------------------------------------------------------ request fence
+
+function headerOf(request, name) {
+  const headers = request && request.headers
+  if (!headers || typeof headers !== 'object') return undefined
+  const value = headers[name]
+  if (Array.isArray(value)) return value.length === 1 ? String(value[0]) : undefined
+  return typeof value === 'string' ? value : undefined
+}
+
+function authorityOf(text, scheme) {
+  if (typeof text !== 'string' || text === '') return null
+  const absolute = /^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//.test(text)
+  try {
+    const url = new URL(absolute ? text : (scheme || 'http:') + '//' + text)
+    if (url.protocol !== 'http:' && url.protocol !== 'https:') return null
+    return url.host.toLowerCase()
+  } catch (error) {
+    return null
+  }
+}
+
+function hostnameOf(authority) {
+  const at = authority.lastIndexOf(':')
+  return at === -1 ? authority : authority.slice(0, at)
+}
+
+function portOf(authority) {
+  const at = authority.lastIndexOf(':')
+  return at === -1 ? '' : authority.slice(at + 1)
+}
+
+function isLoopbackAuthority(authority) {
+  const host = hostnameOf(authority)
+  return host === 'localhost' || host === '127.0.0.1' || host === '[::1]'
+}
+
+/**
+ * Decide whether a request may write one paste file.
+ *
+ * Every branch fails CLOSED; the reference authority is the listener's own
+ * origin (`ctx.webServer.getOrigin()`), whose Host header a DNS rebinding
+ * attacker cannot forge. A not-yet-known origin falls back to the strictest
+ * loopback rule instead of opening up.
+ *
+ * @param request - node:http request (only `headers` is read).
+ * @param origin - the listener's own `http://host:port`, or null when unknown.
+ * @returns null when the request is ours, else a short machine-readable reason.
+ */
+export function refuseRequest(request, origin) {
+  const host = headerOf(request, 'host')
+  if (host === undefined) return 'no-host'
+  const authority = authorityOf(host, 'http:')
+  if (authority === null) return 'bad-host'
+
+  const own = origin === null || origin === undefined ? null : authorityOf(String(origin), 'http:')
+  if (own === null) {
+    if (!isLoopbackAuthority(authority)) return 'foreign-host'
+  } else if (authority !== own) {
+    const sameLoopbackPeer = isLoopbackAuthority(authority)
+      && isLoopbackAuthority(own)
+      && portOf(authority) === portOf(own)
+    if (!sameLoopbackPeer) return 'foreign-host'
+  }
+
+  const site = headerOf(request, 'sec-fetch-site')
+  if (site !== undefined && site !== 'same-origin' && site !== 'none') return 'cross-site'
+
+  const requestOrigin = headerOf(request, 'origin')
+  if (requestOrigin !== undefined && authorityOf(requestOrigin, 'http:') !== authority) return 'foreign-origin'
+
+  if (headerOf(request, MARKER_HEADER) !== MARKER_VALUE) return 'missing-marker'
+
+  return null
+}
+
+// -------------------------------------------------------------- body reader
+
+/**
+ * Read a bounded JSON body. The Client sends one small object; anything else is
+ * a bug or an attack, and neither deserves streaming.
+ *
+ * @param request - node:http request.
+ * @param limit - byte cap.
+ * @returns the parsed value.
+ * @throws Error with `code === 'TOO_LARGE'` past the cap, or a parse error.
+ */
+export function readJsonBody(request, limit = MAX_BODY_BYTES) {
+  return new Promise((resolve, reject) => {
+    const chunks = []
+    let total = 0
+    let failed = false
+    const fail = (error) => {
+      if (failed) return
+      failed = true
+      reject(error)
+    }
+    request.on('data', (chunk) => {
+      if (failed) return
+      total += chunk.length
+      if (total > limit) {
+        const error = new Error('paste: request body too large')
+        error.code = 'TOO_LARGE'
+        fail(error)
+        return
+      }
+      chunks.push(chunk)
+    })
+    request.on('error', fail)
+    request.on('end', () => {
+      if (failed) return
+      try {
+        resolve(JSON.parse(Buffer.concat(chunks).toString('utf8')))
+      } catch (error) {
+        fail(error)
+      }
+    })
+  })
+}
+
+// ------------------------------------------------------------ workspace
+
+/**
+ * Resolve one Session's absolute workspace without activating an Agent.
+ *
+ * @param ctx - host context carrying `sessions` and/or `sessionController`.
+ * @param sessionId - durable Session identity from the Client.
+ * @returns the absolute cwd, or null when the Session is unknown/workspaceless.
+ */
+export async function sessionWorkspace(ctx, sessionId) {
+  const sessions = typeof ctx.get === 'function' ? ctx.get('sessions') : ctx.sessions
+  const attached = sessions !== undefined && sessions !== null && typeof sessions.get === 'function'
+    ? sessions.get(sessionId)
+    : undefined
+  const live = attached === undefined || attached === null ? undefined : attached.header
+  if (live !== undefined && live !== null && typeof live.cwd === 'string') return live.cwd
+
+  const controller = typeof ctx.get === 'function' ? ctx.get('sessionController') : ctx.sessionController
+  if (controller !== undefined && controller !== null && typeof controller.inspect === 'function') {
+    const inspection = await controller.inspect(sessionId)
+    const meta = inspection === undefined || inspection === null ? undefined : inspection.meta
+    if (meta !== undefined && meta !== null && typeof meta.cwd === 'string') return meta.cwd
+  }
+  return null
+}
+
+// -------------------------------------------------------------- the route
+
+/**
+ * The paste store route.
+ *
+ * @param options.resolveWorkspace - `(ctx, sessionId) => Promise<string|null>`,
+ *        injectable so the route is testable without a session store.
+ * @param options.origin - returns the listener's own origin (or null).
+ * @param options.store - `writePasteFile`-shaped writer, injectable for tests.
+ */
+export function createPasteRoute(ctx, options = {}) {
+  const resolve = typeof options.resolveWorkspace === 'function'
+    ? options.resolveWorkspace
+    : (hostCtx, sessionId) => sessionWorkspace(hostCtx, sessionId)
+  const originOf = typeof options.origin === 'function' ? options.origin : () => null
+  const store = typeof options.store === 'function' ? options.store : writePasteFile
+
+  function listenerOrigin() {
+    try {
+      const value = originOf()
+      return typeof value === 'string' && value !== '' ? value : null
+    } catch (error) {
+      return null
+    }
+  }
+
+  return {
+    kind: 'exact',
+    path: PASTE_PATH,
+    handler: async (request, response) => {
+      if (request.method !== 'POST') {
+        response.writeHead(405, { allow: 'POST' })
+        response.end()
+        return
+      }
+      // Refuse before reading a body: a refused request must cost nothing.
+      const refused = refuseRequest(request, listenerOrigin())
+      if (refused !== null) {
+        sendJson(response, 403, { error: 'refused', reason: refused })
+        return
+      }
+
+      let body
+      try {
+        body = await readJsonBody(request)
+      } catch (error) {
+        const tooLarge = error && error.code === 'TOO_LARGE'
+        sendJson(response, tooLarge ? 413 : 400, {
+          ok: false,
+          reason: tooLarge ? 'too-large' : 'bad-json',
+        })
+        return
+      }
+      if (body === null || typeof body !== 'object') {
+        sendJson(response, 400, { ok: false, reason: 'bad-body' })
+        return
+      }
+      const sessionId = typeof body.sessionId === 'string' ? body.sessionId : ''
+      const name = typeof body.name === 'string' ? body.name : ''
+      const text = typeof body.text === 'string' ? body.text : ''
+      if (sessionId === '' || name === '' || text === '') {
+        sendJson(response, 400, { ok: false, reason: 'bad-body' })
+        return
+      }
+      if (Buffer.byteLength(text, 'utf8') > MAX_PASTE_BYTES) {
+        sendJson(response, 413, { ok: false, reason: 'too-large' })
+        return
+      }
+
+      let cwd
+      try {
+        cwd = await resolve(ctx, sessionId)
+      } catch (error) {
+        cwd = null
+      }
+      if (typeof cwd !== 'string' || cwd === '') {
+        // No workspace (unknown Session, a session-less composer): the Client
+        // falls back to an ordinary text paste. Never an error the user sees.
+        sendJson(response, 409, { ok: false, reason: 'no-workspace' })
+        return
+      }
+
+      try {
+        const written = await store({ cwd, name, text })
+        const mention = formatPasteMention(written.relativePath)
+        if (mention === null) {
+          sendJson(response, 422, { ok: false, reason: 'unrepresentable-path' })
+          return
+        }
+        sendJson(response, 200, {
+          ok: true,
+          fileName: written.fileName,
+          relativePath: written.relativePath,
+          mention,
+        })
+      } catch (error) {
+        sendJson(response, 500, {
+          ok: false,
+          reason: 'write-failed',
+          error: error instanceof Error ? error.message : String(error),
+        })
+      }
+    },
+  }
+}
+
+/**
+ * Mount the route once the profile composes a web server.
+ *
+ * `ctx.inject` waits for the service, so a composition without a web server (a
+ * headless run) simply never mounts the route and the Client's paste falls back
+ * to plain text — the feature degrades, the plugin never fails to load.
+ *
+ * @param ctx - host context of this plugin.
+ */
+export function installPasteRoute(ctx) {
+  if (ctx === undefined || ctx === null || typeof ctx.inject !== 'function') return
+  ctx.inject(['webServer'], (hostCtx) => {
+    const webServer = hostCtx.webServer
+    if (webServer === undefined || typeof webServer.register !== 'function') {
+      console.warn('dsh-cds-theme: the webServer service exposes no register(); long pastes stay plain text')
+      return
+    }
+    const origin = () => {
+      try {
+        return typeof webServer.getOrigin === 'function' ? webServer.getOrigin() : null
+      } catch (error) {
+        return null
+      }
+    }
+    hostCtx.effect(
+      () => webServer.register(createPasteRoute(hostCtx, { origin })),
+      'dsh-cds-theme: paste store route',
+    )
+  })
+}
+
+export { PASTE_DIR }

package/lib/paste-store.js

@@ -0,0 +1,130 @@
+/**
+ * Long-paste scratch store: the file half of "a long paste becomes an `@path`".
+ *
+ * WHY A FILE ON DISK. A pasted FILE is the only thing the composer renders as
+ * a compact chip: the host's paste/drop intake (verified in the installed
+ * `@deepseek-ai/dsh-client-ui-conversation` bundle, the `PASTE_COMMAND` handler
+ * around `registerComposerKeymap`) asks the desktop bridge for the real path of
+ * every pasted `File`:
+ *
+ *   const path = bridge?.pathFor(file) ?? ''
+ *   if (path === '' || (!directory && isImageMediaType(file.type))) {
+ *     uploads.push(file)            // → 240×64 upload card
+ *     continue
+ *   }
+ *   const mention = formatFileMention({ path: relativizeToCwd(path, cwd), kind: 'file' }, false)
+ *   references.push({ source: 'reference', ref: mention, … })   // → @-reference chip
+ *   …
+ *   shell.addFiles(references, [])  // → insertFileReferences → chip node
+ *
+ * `bridge.pathFor` is `electron.webUtils.getPathForFile`, which only answers for
+ * files the OS handed to the renderer; a `File` built in JavaScript always gets
+ * `''`. So a plugin cannot synthesize the bridge answer — it must make the path
+ * REAL: write the text to disk here, and let the Client insert the `@relative`
+ * reference itself (see `client/src/paste.js`).
+ *
+ * WHERE. `<session workspace>/.dsh-paste/`, one file per paste, named by the
+ * Client (timestamped, locale-shaped) and never overwritten: the open uses
+ * `wx` and a numbered suffix retries a name collision. The directory is a
+ * visible dot-directory so the user can find and delete these files, and so
+ * `@.dsh-paste/…` resolves like any other workspace-relative mention.
+ *
+ * WHAT IS RETURNED. Only the workspace-relative path (`/` separators) and the
+ * file name. The absolute path never leaves the Host: it is a filesystem-layout
+ * disclosure the browser has no use for.
+ */
+
+import { mkdir, open, unlink } from 'node:fs/promises'
+import path from 'node:path'
+
+/** Directory (relative to the session workspace) holding converted pastes. */
+export const PASTE_DIR = '.dsh-paste'
+
+/** Refuse a paste whose UTF-8 body exceeds this. */
+export const MAX_PASTE_BYTES = 4 * 1024 * 1024
+
+/** Longest file name accepted from the Client, in characters. */
+export const MAX_PASTE_NAME = 180
+
+/** Same reserved-device rule the Client applies (Windows `CON.txt` …). */
+const RESERVED_NAME = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/i
+
+/**
+ * Make a client-supplied name safe as one path component.
+ *
+ * The Client already sanitizes (`client/src/paste.js`), but the Host must not
+ * trust a browser string that becomes a file name: this strips separators,
+ * Windows-rejected characters, control characters, leading/trailing dots and
+ * spaces, reserved device names, and caps the length. An unusable name becomes
+ * `pasted-text.txt`.
+ */
+export function sanitizePasteName(name) {
+  let value = String(name === null || name === undefined ? '' : name)
+    .replace(/[<>:"/\\|?*\u0000-\u001f]/g, '-')
+    .replace(/-{2,}/g, '-')
+    .replace(/^[\s.]+|[\s.]+$/g, '')
+  if (value === '') value = 'pasted-text.txt'
+  if (RESERVED_NAME.test(value)) value = '_' + value
+  if (value.length > MAX_PASTE_NAME) value = value.slice(0, MAX_PASTE_NAME)
+  return value
+}
+
+/**
+ * The composer's mention spelling for a workspace-relative path, in the host's
+ * own grammar (`formatFileMention` in ui-conversation): a path with whitespace
+ * is quoted, a quote/control character makes the token unrepresentable.
+ *
+ * @returns the `@path` / `@"path"` token, or null when the grammar cannot carry it.
+ */
+export function formatPasteMention(relativePath) {
+  const normalized = String(relativePath === null || relativePath === undefined ? '' : relativePath)
+    .replace(/\\/g, '/')
+  if (normalized === '') return null
+  if (/[\u0000-\u001f\u007f-\u009f"]/u.test(normalized)) return null
+  return /\s/u.test(normalized) ? '@"' + normalized + '"' : '@' + normalized
+}
+
+/**
+ * Write one paste under `<cwd>/.dsh-paste/`, never overwriting an existing file.
+ *
+ * @param cwd - absolute session workspace root.
+ * @param name - requested file name (sanitized here).
+ * @param text - the pasted plain text, written as UTF-8.
+ * @returns `{ fileName, relativePath }` with `/` separators.
+ * @throws when the directory cannot be created or every candidate name exists.
+ */
+export async function writePasteFile({ cwd, name, text }) {
+  if (typeof cwd !== 'string' || cwd === '' || !path.isAbsolute(cwd)) {
+    throw new Error('paste: the session workspace is not an absolute path')
+  }
+  const directory = path.join(cwd, PASTE_DIR)
+  await mkdir(directory, { recursive: true })
+
+  const safe = sanitizePasteName(name)
+  const extension = path.extname(safe)
+  const stem = extension === '' ? safe : safe.slice(0, safe.length - extension.length)
+
+  for (let attempt = 1; attempt <= 100; attempt += 1) {
+    const fileName = attempt === 1 ? safe : stem + '-' + attempt + extension
+    const target = path.join(directory, fileName)
+    let handle
+    try {
+      handle = await open(target, 'wx')
+    } catch (error) {
+      if (error && error.code === 'EEXIST') continue
+      throw error
+    }
+    try {
+      await handle.writeFile(text, 'utf8')
+    } catch (error) {
+      // A half-written file is worse than no file: the name would be taken by
+      // an empty scratch the user cannot distinguish from a real paste.
+      await handle.close().catch(() => {})
+      await unlink(target).catch(() => {})
+      throw error
+    }
+    await handle.close()
+    return { fileName, relativePath: PASTE_DIR + '/' + fileName }
+  }
+  throw new Error('paste: every candidate file name is taken')
+}

package/locale/en.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Claude Design System Theme",
+    "description": "Re-maps the interface onto CDS: warm-gray surfaces, clay brand accent, dual-ring focus and organic motion, with component-level refinement of the composer, sidebar, message rows and code blocks."
+  }
+}

package/locale/zh.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Claude Design System 主题",
+    "description": "把界面重映射到 CDS：暖灰表面、陶土橙品牌色、双环焦点与有机动效，并对输入框、侧栏、消息行与代码块做组件级细化。"
+  }
+}

package/package.json

@@ -1,6 +1,69 @@
 {
   "name": "dsh-cds-theme",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "description": "DeepSeek Harness 的 Claude Design System 主题插件：把宿主的 --dsw-* 令牌整体重映射到 CDS 的暖灰表面阶梯、陶土橙品牌色、双环焦点与有机动效，并对输入框、侧栏、消息行、代码块做组件级细化。明暗两套配色，配色/圆角/阴影走 ctx.theme.overrideTokens，组件细化走插件自有样式表。 / Claude Design System theme for DeepSeek Harness: remaps the host's --dsw-* tokens onto CDS warm-gray surfaces, clay brand accent, dual-ring focus and organic motion, then refines the composer, sidebar, message rows and code blocks at the component level.",
+  "type": "module",
+  "main": "lib/index.js",
+  "icon": "./icon.svg",
+  "license": "MIT",
+  "author": "HwFee <1744567281@qq.com>",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "engines": {
+    "node": "^22.19.0 || >=24.0.0"
+  },
+  "keywords": [
+    "deepseek",
+    "deepseek-harness",
+    "dsh",
+    "dsh-plugin",
+    "theme",
+    "claude",
+    "design-system",
+    "cds",
+    "appearance"
+  ],
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "inject": [
+        "@deepseek-ai/dsh-client-ui-renderer",
+        "@deepseek-ai/dsh-client-ui-settings-general"
+      ],
+      "platform": "web",
+      "immediately": true
+    }
+  },
+  "exports": {
+    ".": {
+      "default": "./lib/index.js"
+    },
+    "./client": "./client/client.js",
+    "./cordis.patch.yml": "./cordis.patch.yml",
+    "./locale/*.json": "./locale/*.json",
+    "./icon": "./icon.svg",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib",
+    "client/client.js",
+    "locale",
+    "assets",
+    "cordis.patch.yml",
+    "icon.svg",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "node tools/build-client.mjs",
+    "build:check": "node tools/build-client.mjs --check",
+    "test": "node tools/build-client.mjs --check && node test/tokens.test.mjs && node test/css.test.mjs && node test/bridge.test.mjs && node test/fonts.test.mjs && node test/typography.test.mjs && node test/hero.test.mjs && node test/markdown.test.mjs && node test/locale.test.mjs && node test/section.test.mjs && node test/thememode.test.mjs && node test/navicon.test.mjs && node test/host.test.mjs && node test/styles.test.mjs && node test/master-switch.test.mjs && node test/paste.test.mjs && node test/new-session-layout.test.mjs && node test/prefer-cjk.test.mjs && node test/ripple.test.mjs",
+    "verify": "node tools/verify.mjs"
+  },
+  "devDependencies": {
+    "esbuild": "0.25.10"
+  }
+}