@hwfee/dsh-git-bash 0.0.0-stage → 0.1.0

package/lib/mode-route.js

@@ -0,0 +1,204 @@
+/**
+ * The mode bridge: the page → host half of the `默认 shell` setting.
+ *
+ * WHY A ROUTE AND NOT AN EVENT. The settings row lives in the browser process;
+ * `run_shell` lives in the host process. `ctx.emit('git-bash/mode', …)` reaches
+ * browser listeners only, so the host kept its boot default (`auto`) FOREVER —
+ * choosing "Windows PowerShell" repainted the row and changed nothing the model
+ * ran. That was invisible because the row is client-rendered: it named the mode
+ * the user picked while every command still went to Git Bash.
+ *
+ * A same-origin POST to the host's own web server is the smallest bridge that
+ * crosses the process boundary without adding the Typert RPC dependency to this
+ * package. The fence is the same one `dsh-system-fonts`' catalogue route uses:
+ * the custom header is impossible for an `<img>`/`<form>`/navigation to send,
+ * a cross-origin fetch that set it would preflight and be refused, and the Host
+ * / Origin / Sec-Fetch-Site checks stop DNS rebinding and cross-site forms.
+ *
+ * @module @hwfee/dsh-git-bash/mode-route
+ */
+
+import { MODES } from './mode.js'
+
+/** Route the page posts the selected mode to. */
+export const MODE_PATH = '/dsh-git-bash/mode'
+
+/** The marker every legitimate request carries (see the header comment). */
+export const MODE_MARKER_HEADER = 'x-dsh-git-bash'
+export const MODE_MARKER_VALUE = '1'
+
+/** Largest body accepted. A mode is a three-letter word; 1 KiB is generous. */
+export const MAX_BODY_BYTES = 1024
+
+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 {
+    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 change the mode.
+ *
+ * Fails CLOSED on every branch, and checks only headers — the body is never
+ * read for a refused request.
+ *
+ * @param {object} request node:http request (only `headers` is read)
+ * @param {string | null} origin the listener's own `http://host:port`
+ * @returns {string | null} null when the request is ours, else a 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, MODE_MARKER_HEADER) !== MODE_MARKER_VALUE) return 'missing-marker'
+
+  return null
+}
+
+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)
+}
+
+function readBody(request) {
+  return new Promise((resolve, reject) => {
+    let size = 0
+    const chunks = []
+    request.on('data', (chunk) => {
+      size += chunk.length
+      if (size > MAX_BODY_BYTES) {
+        reject(new Error('body-too-large'))
+        request.destroy?.()
+        return
+      }
+      chunks.push(chunk)
+    })
+    request.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')))
+    request.on('error', reject)
+  })
+}
+
+/**
+ * The mode route.
+ *
+ * `POST { mode }` sets; `GET` reports the host's current value. The read half
+ * exists because the host's mode was otherwise INVISIBLE from the page: the
+ * row could show one value while the host ran another, and no diagnostic could
+ * tell them apart. It is fenced exactly like the write.
+ *
+ * @param {(mode: string) => void} onMode called with a VALIDATED mode
+ * @param {object} [options]
+ * @param {() => string | null} [options.origin] the listener's own origin
+ * @param {() => string} [options.readMode] the host's current mode
+ * @returns {{ kind: 'exact', path: string, handler: Function }} the route
+ */
+export function createModeRoute(onMode, options = {}) {
+  const originOf = typeof options.origin === 'function' ? options.origin : () => null
+  const read = typeof options.readMode === 'function' ? options.readMode : () => 'auto'
+  const origin = () => {
+    try {
+      const value = originOf()
+      return typeof value === 'string' && value !== '' ? value : null
+    } catch {
+      return null
+    }
+  }
+
+  return {
+    kind: 'exact',
+    path: MODE_PATH,
+    handler: async (request, response) => {
+      if (request.method !== 'POST' && request.method !== 'GET') {
+        response.writeHead(405, { allow: 'GET, POST' })
+        response.end()
+        return
+      }
+      const refused = refuseRequest(request, origin())
+      if (refused !== null) {
+        sendJson(response, 403, { error: 'refused', reason: refused })
+        return
+      }
+      if (request.method === 'GET') {
+        sendJson(response, 200, { ok: true, mode: read() })
+        return
+      }
+      let body
+      try {
+        body = await readBody(request)
+      } catch (error) {
+        sendJson(response, 413, { error: String(error?.message ?? 'body') })
+        return
+      }
+      let parsed
+      try {
+        parsed = JSON.parse(body)
+      } catch {
+        sendJson(response, 400, { error: 'invalid-json' })
+        return
+      }
+      if (parsed === null || typeof parsed !== 'object' || typeof parsed.mode !== 'string') {
+        sendJson(response, 400, { error: 'invalid-mode' })
+        return
+      }
+      if (!MODES.includes(parsed.mode)) {
+        sendJson(response, 400, { error: 'unknown-mode', mode: parsed.mode })
+        return
+      }
+      onMode(parsed.mode)
+      sendJson(response, 200, { ok: true, mode: parsed.mode })
+    },
+  }
+}

package/lib/mode.js

@@ -0,0 +1,244 @@
+/**
+ * The three shell modes, and the decision each one makes.
+ *
+ * THIS MODULE IS SHARED BY BOTH HALVES. The client imports it for the values and
+ * the storage helpers (`client/src/store.js`), and the host imports it for
+ * `chooseShell()` (`lib/index.js`). It is therefore DEPENDENCY-FREE — no
+ * `node:` imports — because it is also bundled into `client/client.js`. Executable
+ * discovery lives in `resolve.js` (host-only) and is injected here as a function.
+ *
+ * THE RULE THAT MATTERS IS ABOUT FALLBACK.
+ *
+ *   auto     may fall back, and its `source` always says which branch was taken
+ *            and why ("git --exec-path (auto)" / "known path (auto fallback)").
+ *            A fallback that does not announce itself is indistinguishable from
+ *            the setting doing nothing.
+ *   pwsh     may not fall back to Git Bash.
+ *   gitbash  may not fall back to PowerShell. Handing PowerShell to a user who
+ *            asked for Git Bash turns every `grep`, `$VAR` and `&&` into a
+ *            confusing failure that looks like the tool is broken — worse than
+ *            refusing to run.
+ *
+ * @module mode
+ */
+
+/** The values the settings row may store, in display order. */
+export const MODES = ['auto', 'pwsh', 'gitbash']
+
+/** A fresh install follows the machine, which is what an unconfigured user means. */
+export const DEFAULT_MODE = 'auto'
+
+/** Mode → the label key in this plugin's dictionaries. */
+export const MODE_LABELS = {
+  auto: 'shell.mode.auto',
+  pwsh: 'shell.mode.pwsh',
+  gitbash: 'shell.mode.gitbash',
+}
+
+/**
+ * Resolved shell family → the label key in this plugin's dictionaries.
+ *
+ * THE KINDS ARE NOT MODES. `pwsh` is one mode but two families (`pwsh` for
+ * PowerShell 7, `windows-powershell` for 5.1), and `gitbash` is one mode that
+ * resolves to `posix-bash` away from Windows. The row must name the thing that
+ * will actually run, not the setting the user clicked.
+ */
+export const KIND_LABELS = {
+  gitbash: 'shell.kind.gitbash',
+  'posix-bash': 'shell.kind.posix-bash',
+  pwsh: 'shell.kind.pwsh',
+  'windows-powershell': 'shell.kind.windows-powershell',
+}
+
+/**
+ * Why a mode could not be satisfied, in the user's language.
+ *
+ * ONE SOURCE FOR TWO READERS: the settings row renders this, and the tool throws
+ * it. Two copies of these sentences would drift, and the row's job is to explain
+ * the same failure the model reports.
+ */
+export const REASON_LABELS = {
+  'gitbash-not-found': 'shell.reason.gitbash-not-found',
+  'pwsh-not-found': 'shell.reason.pwsh-not-found',
+  'no-shell-for-platform': 'shell.reason.no-shell-for-platform',
+  'no-shell-found': 'shell.reason.no-shell-found',
+}
+
+/**
+ * The key the FIRST build of this plugin wrote a boolean under.
+ *
+ * It answered a DIFFERENT question ("keep the platform shell tool visible beside
+ * run_shell"), so it cannot be read as a mode directly. It is never deleted and
+ * never re-read as a value: {@link migrateLegacyMode} translates the one
+ * unambiguous case (`'false'` — the user asked to run only through Git Bash) and
+ * leaves everything else at the default. The string is the historical fact; it
+ * must not be renamed, or those users' choice is lost.
+ */
+export const LEGACY_BOOLEAN_KEY = '@hwfee/dsh-git-bash:exposeNativeShell'
+
+/** Whether a stored value is one of the three modes. */
+export function isMode(value) {
+  return typeof value === 'string' && MODES.includes(value)
+}
+
+/**
+ * Coerce anything to a mode.
+ *
+ * A corrupt storage entry, a value from a future version, or an unknown string
+ * all land on `auto`: that is the setting that cannot be wrong, because it
+ * follows the machine. Running commands beats refusing over a bad preference.
+ *
+ * @param {unknown} value
+ * @returns {'auto' | 'pwsh' | 'gitbash'}
+ */
+export function normalizeMode(value) {
+  return isMode(value) ? value : DEFAULT_MODE
+}
+
+/**
+ * Read the stored mode.
+ *
+ * Every failure path returns the default: private mode throws on the property
+ * READ itself (before any method runs), and storage may be disabled entirely. A
+ * settings page must render regardless.
+ *
+ * @param {Storage | undefined} storage the storage object, or undefined
+ * @param {string} key the mode key
+ * @returns {'auto' | 'pwsh' | 'gitbash'} the mode in force
+ */
+export function readMode(storage, key) {
+  if (storage === null || storage === undefined) return DEFAULT_MODE
+  let raw
+  try {
+    raw = storage.getItem(key)
+  } catch {
+    return DEFAULT_MODE
+  }
+  return normalizeMode(raw)
+}
+
+/**
+ * Persist a mode.
+ *
+ * Silent on failure: quota-exceeded and private-mode throws must not break the
+ * settings page the user is clicking through.
+ *
+ * @param {Storage | undefined} storage the storage object, or undefined
+ * @param {string} key the mode key
+ * @param {string} mode the chosen mode
+ * @returns {boolean} whether the write landed
+ */
+export function writeMode(storage, key, mode) {
+  if (storage === null || storage === undefined) return false
+  if (!isMode(mode)) return false
+  try {
+    storage.setItem(key, mode)
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Translate the old boolean preference into the new mode key, once.
+ *
+ * The mapping is deliberately conservative, because the old key measured a
+ * different thing:
+ *
+ *   'false'  the user turned the platform shell OFF, i.e. asked for Git Bash to
+ *            be the only way commands run → `gitbash`
+ *   'true'   the default; nothing was expressed about the shell → `auto`, which
+ *            prefers Git Bash anyway, so behaviour is unchanged
+ *   absent / anything else → no migration; {@link readMode} returns the default
+ *
+ * A value already present under the new key always wins, so the migration can
+ * only ever run once and can never overwrite a newer choice.
+ *
+ * @param {Storage | undefined} storage the storage object, or undefined
+ * @param {string} key the new mode key
+ * @returns {string | null} the migrated mode, or null when nothing was migrated
+ */
+export function migrateLegacyMode(storage, key) {
+  if (storage === null || storage === undefined) return null
+  let current
+  try {
+    current = storage.getItem(key)
+  } catch {
+    return null
+  }
+  if (isMode(current)) return null
+
+  let legacy
+  try {
+    legacy = storage.getItem(LEGACY_BOOLEAN_KEY)
+  } catch {
+    return null
+  }
+  const migrated = legacy === 'false' ? 'gitbash' : legacy === 'true' ? DEFAULT_MODE : null
+  if (migrated === null) return null
+  try {
+    storage.setItem(key, migrated)
+  } catch {
+    // The value still applies for this session; the next launch retries.
+  }
+  return migrated
+}
+
+/**
+ * Choose the shell for a mode.
+ *
+ * `resolve(kind)` is injected so this module stays free of `node:` imports and
+ * the tests can describe a machine instead of probing one. Its kinds are the
+ * ones `resolve.js` produces: `gitbash`, `pwsh`, `windows-powershell`,
+ * `posix-bash`.
+ *
+ * @param {'auto' | 'pwsh' | 'gitbash' | string} mode the selected mode
+ * @param {object} deps
+ * @param {(kind: string) => ({ kind: string, path: string, source: string } | null)} deps.resolve
+ *        resolves one shell kind, or null
+ * @param {string} [deps.platform] `process.platform`, injected for tests
+ * @returns {{ ok: true, shell: { kind: string, path: string, source: string } }
+ *   | { ok: false, reason: string }} the decision — a failure is a VALUE, never
+ *   an exception, because the settings row has to render it
+ */
+export function chooseShell(mode, deps = {}) {
+  const resolve = typeof deps.resolve === 'function' ? deps.resolve : () => null
+  const platform = deps.platform ?? 'win32'
+  const requested = normalizeMode(mode)
+  const windows = platform === 'win32'
+
+  if (requested === 'gitbash') {
+    const found = resolve(windows ? 'gitbash' : 'posix-bash')
+    if (found === null) return { ok: false, reason: 'gitbash-not-found' }
+    return { ok: true, shell: found }
+  }
+
+  if (requested === 'pwsh') {
+    // Windows PowerShell is a Windows program. On POSIX the honest answer is
+    // "not available here", not "not installed".
+    if (!windows) return { ok: false, reason: 'no-shell-for-platform' }
+    const found = resolve('pwsh')
+    if (found === null) return { ok: false, reason: 'pwsh-not-found' }
+    return { ok: true, shell: found }
+  }
+
+  // AUTO.
+  if (windows) {
+    const gitbash = resolve('gitbash')
+    if (gitbash !== null) {
+      return { ok: true, shell: { ...gitbash, source: gitbash.source + ' (auto)' } }
+    }
+    const fallback = resolve('pwsh')
+    if (fallback !== null) {
+      return {
+        ok: true,
+        shell: { ...fallback, source: fallback.source + ' (auto fallback)' },
+      }
+    }
+    return { ok: false, reason: 'no-shell-found' }
+  }
+
+  const posixBash = resolve('posix-bash')
+  if (posixBash === null) return { ok: false, reason: 'no-shell-found' }
+  return { ok: true, shell: { ...posixBash, source: posixBash.source + ' (auto)' } }
+}

package/lib/resolve.js

@@ -0,0 +1,161 @@
+/**
+ * Finding the executables: Git Bash, PowerShell, and the POSIX shell.
+ *
+ * THE RULE THAT MATTERS MOST IS ABOUT GIT BASH. On Windows `bash` is often on
+ * PATH as `C:\Windows\System32\bash.exe` — the WSL stub. It IS bash, it IS on
+ * PATH, and it is the WRONG shell: a different filesystem view (`/mnt/c/...`), a
+ * different user, and no `git` from the Windows install. A resolver that tries
+ * `where bash` first picks it and every subsequent command fails in a way that
+ * looks like the plugin is broken.
+ *
+ * So Git Bash is located from `git --exec-path`, which names the Git install the
+ * user actually works with; its `bin/bash.exe` is the shell Git itself ships.
+ *
+ * @module resolve
+ */
+
+import { execFile, execFileSync } from 'node:child_process'
+import { existsSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+
+/**
+ * Git Bash locations to try after `git --exec-path`.
+ *
+ * A fixed list, not a PATH search: PATH is where the WSL stub hides.
+ */
+export const GITBASH_CANDIDATES = [
+  'C:/Program Files/Git/bin/bash.exe',
+  'C:/Program Files/Git/usr/bin/bash.exe',
+  'C:/Program Files (x86)/Git/bin/bash.exe',
+  'C:/ProgramData/chocolatey/bin/bash.exe',
+]
+
+/**
+ * PowerShell locations, newest first.
+ *
+ * PowerShell 7 (`pwsh.exe`) is tried before Windows PowerShell 5.1: it is the
+ * maintained one, and VS Code's own detection prefers it for the same reason.
+ * Both are reported with a distinct `kind` so the row can say which one ran.
+ */
+export const PWSH_CANDIDATES = [
+  { path: 'C:/Program Files/PowerShell/7/pwsh.exe', kind: 'pwsh' },
+  { path: 'C:/Program Files/PowerShell/6/pwsh.exe', kind: 'pwsh' },
+  { path: 'C:/Windows/System32/WindowsPowerShell/v1.0/powershell.exe', kind: 'windows-powershell' },
+]
+
+/** Normalize a Windows path to forward slashes, the shape `git --exec-path` uses. */
+const slash = (value) => value.replaceAll('\\', '/')
+
+/**
+ * Build a resolver bound to one environment.
+ *
+ * @param {object} [deps]
+ * @param {(path: string) => boolean} [deps.exists] filesystem probe, for tests
+ * @param {(command: string, args: string[]) => string} [deps.execSync] sync runner, for tests
+ * @param {NodeJS.ProcessEnv} [deps.env] the environment
+ * @param {string} [deps.platform] `process.platform`
+ * @returns {(kind: string) => object | null} resolves one shell kind
+ */
+export function createResolver(deps = {}) {
+  const exists = deps.exists ?? existsSync
+  const runSync = deps.execSync ?? defaultExecSync
+  const env = deps.env ?? process.env
+  const platform = deps.platform ?? process.platform
+
+  /** Git Bash: the override, then `git --exec-path`, then the known paths. */
+  function gitbash() {
+    const override = env.DSH_GIT_BASH
+    if (typeof override === 'string' && override !== '' && exists(override)) {
+      return { kind: 'gitbash', path: slash(override), source: 'DSH_GIT_BASH' }
+    }
+    if (platform === 'win32') {
+      try {
+        const execPath = runSync('git', ['--exec-path']).trim()
+        if (execPath !== '') {
+          const fromGit = slash(join(dirname(dirname(dirname(execPath))), 'bin', 'bash.exe'))
+          if (exists(fromGit)) return { kind: 'gitbash', path: fromGit, source: 'git --exec-path' }
+        }
+      } catch {
+        // `git` is not on PATH; fall through to the known locations.
+      }
+      for (const candidate of GITBASH_CANDIDATES) {
+        if (exists(candidate)) return { kind: 'gitbash', path: slash(candidate), source: 'known path' }
+      }
+      return null
+    }
+    // POSIX: the bash on PATH IS the shell this mode means.
+    try {
+      const which = runSync('sh', ['-c', 'command -v bash']).trim()
+      if (which !== '') return { kind: 'posix-bash', path: which, source: 'PATH' }
+    } catch {
+      // No bash at all.
+    }
+    return null
+  }
+
+  /** PowerShell: 7 before 5.1, then PATH. */
+  function pwsh() {
+    if (platform !== 'win32') return null
+    for (const candidate of PWSH_CANDIDATES) {
+      if (exists(candidate.path)) {
+        return { kind: candidate.kind, path: slash(candidate.path), source: 'known path' }
+      }
+    }
+    try {
+      const which = runSync('where', ['pwsh']).trim().split(/\r?\n/)[0]
+      if (which !== '') return { kind: 'pwsh', path: slash(which), source: 'PATH' }
+    } catch {
+      // Not installed anywhere findable.
+    }
+    return null
+  }
+
+  /** The POSIX shell, on a POSIX platform. */
+  function posixBash() {
+    try {
+      const which = runSync('sh', ['-c', 'command -v bash']).trim()
+      if (which !== '') return { kind: 'posix-bash', path: which, source: 'PATH' }
+    } catch {
+      // Fall through.
+    }
+    return null
+  }
+
+  return function resolve(kind) {
+    switch (kind) {
+      case 'gitbash': return gitbash()
+      case 'pwsh': return pwsh()
+      case 'posix-bash': return posixBash()
+      default: return null
+    }
+  }
+}
+
+/**
+ * Run a command synchronously, returning stdout.
+ *
+ * @param {string} command the executable
+ * @param {string[]} args its arguments
+ * @returns {string} stdout
+ */
+function defaultExecSync(command, args) {
+  return execFileSync(command, args, { encoding: 'utf8', windowsHide: true, timeout: 5000 })
+}
+
+/**
+ * Run a command asynchronously, resolving stdout.
+ *
+ * Kept for the tool path, which must not block the event loop.
+ *
+ * @param {string} command the executable
+ * @param {string[]} args its arguments
+ * @returns {Promise<string>} stdout
+ */
+export function execAsync(command, args) {
+  return new Promise((resolve, reject) => {
+    execFile(command, args, { windowsHide: true, timeout: 5000 }, (error, stdout) => {
+      if (error) reject(error)
+      else resolve(stdout)
+    })
+  })
+}

package/locale/en.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Git Bash as default shell",
+    "description": "Run shell commands in Git Bash instead of PowerShell. Resolves the real Git for Windows bash (not the WSL stub), exposes a run_shell tool, and shows which shell is in effect."
+  }
+}

package/locale/zh.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Git Bash 默认 shell",
+    "description": "用 Git Bash 而不是 PowerShell 执行 shell 命令。自动定位真正的 Git for Windows bash（不用 WSL 的替身），提供 run_shell 工具，并在设置里显示当前用的是哪个 shell。"
+  }
+}

package/package.json

@@ -1,6 +1,64 @@
 {
   "name": "@hwfee/dsh-git-bash",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "DeepSeek Harness 的 Git Bash 默认 shell：把 Windows 上的默认命令解释器从 PowerShell 换成 Git Bash，并暴露一个 run_shell 工具。自动从 git --exec-path 定位 Git Bash（WSL 的 bash 不算），找不到时降级而不是让插件消失。 / Git Bash as the default shell for DeepSeek Harness on Windows: resolves Git Bash from `git --exec-path` (never the WSL stub), exposes a run_shell tool, and degrades visibly instead of vanishing when the shell is missing.",
+  "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",
+    "git-bash",
+    "shell",
+    "windows"
+  ],
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "inject": [
+        "@deepseek-ai/dsh-client-ui-renderer"
+      ],
+      "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",
+    "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/manifest.test.mjs && node test/mode.test.mjs && node test/mode-route.test.mjs && node test/resolve.test.mjs && node test/tool.test.mjs && node test/store.test.mjs && node test/settings-row.test.mjs"
+  },
+  "devDependencies": {
+    "esbuild": "0.25.10"
+  }
+}