dsh-autodetect 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Xiaoph123
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,163 @@
+# AutoDetect
+
+<p align="center">
+  <strong>DeepSeek Harness Web 官方侧边栏的 Windows 编码安全文件查看器</strong><br>
+  <sub>在官方文件标签页中查看和编辑脚本，同时保留原始编码、BOM 与换行格式。</sub>
+</p>
+
+<p align="center">
+  <a href="https://github.com/Xiaoph123/dsh-autodetect"><img src="https://img.shields.io/badge/DeepSeek-Harness%20Web-4b6bfb" alt="DeepSeek Harness Web"></a>
+  <a href="https://www.npmjs.com/package/dsh-autodetect"><img src="https://img.shields.io/npm/v/dsh-autodetect" alt="npm version"></a>
+  <a href="https://github.com/Xiaoph123/dsh-autodetect/blob/main/LICENSE"><img src="https://img.shields.io/badge/license-MIT-green" alt="MIT license"></a>
+</p>
+
+> [!IMPORTANT]
+> **适配边界**：本项目是 **DeepSeek Harness Web 官方侧边栏插件**，使用 DSH 官方 `client-runtime`、`client-ui-slots` 和 `client-ui-sidebar-right` 扩展接口。它**不适配第三方 DeepSeek 侧边栏、浏览器扩展、桌面客户端或其他非 Harness Web 宿主**。
+
+## 为什么需要 AutoDetect？
+
+Windows 工具链里，`.bat`、`.cmd`、`.ini`、`.vbs` 和 `.ps1` 经常混用 UTF-8、UTF-16、GBK、GB18030 与不同换行格式。AutoDetect 让这些文件直接出现在 Harness Web 的官方右侧文件标签页中，编辑后尽量按原格式写回。
+
+## 功能
+
+| 能力 | 说明 |
+| --- | --- |
+| 编码检测 | UTF-8、UTF-16、UTF-32、GBK、GB18030、CP1252、Shift-JIS 等 |
+| 格式保留 | 识别并保留 BOM 与 LF、CRLF、CR 换行 |
+| 文件保护 | 二进制文件禁止编辑；路径限制在当前会话工作区 |
+| 并发保护 | 保存前校验 SHA-256，检测磁盘外部修改 |
+| 可靠写入 | 保存前生成 `.autodetect.bak`，使用临时文件和原子替换 |
+| 对话协作 | 选中文本后可添加到当前 Harness 对话 |
+
+## 安装
+
+### 推荐：通过 npm 包安装
+
+先确认已安装 Node.js、Python 3.10+ 和 DeepSeek Harness Web。发布到 npm 后，推荐直接执行这一条命令：
+
+```powershell
+dsh plugin --profile web install dsh-autodetect --replace --yes
+```
+
+`dsh` 会从 npm 获取 `dsh-autodetect`，并把它注册到 **Harness Web 官方侧边栏**。安装或更新后重启 Harness Web。
+
+如果你的 `dsh` 版本不支持从 npm 包名解析，也可以先下载包再使用本地目录：
+
+```powershell
+npm install dsh-autodetect
+dsh plugin --profile web install .\node_modules\dsh-autodetect --replace --yes
+```
+
+> 如果当前版本的 `dsh` CLI 不接受 npm 包名，请使用兼容方式：
+>
+> ```powershell
+> git clone https://github.com/Xiaoph123/dsh-autodetect.git
+> dsh plugin --profile web install .\dsh-autodetect --replace --yes
+> ```
+
+### 开发链接安装
+
+```powershell
+git clone https://github.com/Xiaoph123/dsh-autodetect.git
+cd dsh-autodetect
+dsh plugin --profile web install . --link --replace --yes
+```
+
+### Python 依赖
+
+插件后端需要 `charset-normalizer`：
+
+```powershell
+py -3 -m pip install -r requirements.txt
+```
+
+如果 Harness 使用的不是默认 Python，可以指定：
+
+```powershell
+$env:AUTODETECT_PYTHON = 'C:\Path\To\python.exe'
+```
+
+## 使用
+
+1. 启动 DeepSeek Harness Web。
+2. 在工作区打开 `.bat`、`.cmd`、`.ini`、`.vbs` 或 `.ps1` 文件。
+3. AutoDetect 会在官方右侧文件标签页中检测编码并显示内容。
+4. 修改后使用宿主工具栏或插件的保存按钮写回文件。
+
+保存会沿用读取时的编码、BOM 和换行格式。如果文件在编辑期间被其他程序修改，保存会被拒绝，请重新加载后再操作。
+
+## 工作原理
+
+插件由两个部分组成：
+
+- **Node.js Host**：注册 `/autodetect/api/read` 和 `/autodetect/api/write`，执行会话工作区校验、SHA-256 并发检查和备份。
+- **Python Codec Helper**：读取原始字节，检测编码、BOM 和换行格式，并按元数据原子写回。
+
+客户端通过 Harness 官方 Sidebar slots 注册文件标签页，只匹配 `dsh-resource://file/**` 下的目标扩展名。
+
+## 项目结构
+
+```text
+dsh-autodetect/
+├─ lib/
+│  ├─ index.js             # Host 路由和 Python Helper 调用
+│  └─ client.js            # Harness 官方 Sidebar 文件标签页
+├─ python/
+│  └─ autodetect_codec.py  # 编码检测、读取和写入
+├─ tests/
+│  ├─ test_codec.py        # 编码与文件写入测试
+│  └─ test_package.mjs     # npm 元数据和 README 回归测试
+├─ cordis.patch.yml        # DSH Web 插件挂载配置
+├─ package.json
+├─ requirements.txt
+└─ README.md
+```
+
+## 开发与测试
+
+```powershell
+npm test
+npm run pack:check
+node --check lib\index.js
+```
+
+`npm run pack:check` 会检查最终 npm 包内容，不会把 `node_modules`、Python 缓存或备份文件打进去。
+
+## 发布
+
+维护者登录 npm 后执行：
+
+```powershell
+npm login
+npm publish --access public
+```
+
+发布新版本前先更新 `package.json` 中的版本号，并运行：
+
+```powershell
+npm version patch
+npm run pack:check
+npm publish --access public
+```
+
+## 常见问题
+
+### 安装后看不到文件标签页
+
+确认宿主是 **DeepSeek Harness Web**，插件安装目标是 `--profile web`，并重启 Harness Web。第三方侧边栏不在支持范围内。
+
+### 保存时报文件已被修改
+
+这是 SHA-256 并发保护触发。重新打开文件、确认内容后再保存，避免覆盖其他程序的修改。
+
+### Python 依赖找不到
+
+使用 Harness 实际调用的 Python 解释器安装 `requirements.txt`，必要时设置 `AUTODETECT_PYTHON`。
+
+## 许可证
+
+[MIT License](LICENSE)
+
+## 反馈与贡献
+
+欢迎通过 [GitHub Issues](https://github.com/Xiaoph123/dsh-autodetect/issues) 提交问题。反馈时请注明 Harness Web 版本、Node.js/Python 版本，以及是否使用了官方侧边栏宿主。

package/lib/client.js

@@ -0,0 +1,351 @@
+window.__ModuleLoader__.load({
+  id: 'dsh-autodetect',
+  factory: (require) => {
+    const React = require('react')
+    const { createPortal } = require('react-dom')
+    const { useEffect, useLayoutEffect, useMemo, useRef, useState } = React
+    const inject = ['slots', 'sidebarRightTabs']
+    const EXTENSIONS = ['bat', 'cmd', 'ini', 'vbs', 'ps1']
+    const style = { position: 'relative', display: 'flex', flexDirection: 'column', height: '100%', minHeight: 0, fontFamily: 'ui-monospace, Consolas, monospace' }
+    const editorLayoutStyle = { display: 'flex', flex: 1, minHeight: 0, overflow: 'hidden', background: 'transparent' }
+    const gutterStyle = { width: '48px', flex: '0 0 48px', overflow: 'hidden', padding: '12px 8px 24px 0', boxSizing: 'border-box', textAlign: 'right', userSelect: 'none', color: 'var(--dsw-alias-label-tertiary, #888)', font: 'var(--dsw-font-markdown-code-block-small, 12px/18px ui-monospace, SFMono-Regular, Menlo, monospace)', whiteSpace: 'pre', lineHeight: '18px' }
+    const editorStyle = { flex: 1, width: '0', minHeight: 0, overflow: 'auto', boxSizing: 'border-box', padding: '12px 16px 24px', outline: 0, background: 'transparent', color: 'var(--dsw-alias-label-primary, inherit)', font: 'var(--dsw-font-markdown-code-block-small, 12px/18px ui-monospace, SFMono-Regular, Menlo, monospace)', lineHeight: '18px', whiteSpace: 'pre', overflowWrap: 'normal' }
+    const barStyle = { display: 'flex', gap: '8px', alignItems: 'center', padding: '6px 10px', borderBottom: '1px solid var(--border-color, #ddd)', fontFamily: 'system-ui, sans-serif', fontSize: '12px' }
+    const selectionButtonGap = 10
+    const selectionButtonStyle = { position: 'fixed', zIndex: 1000, padding: '5px 9px', border: '1px solid var(--border-color, #555)', borderRadius: '4px', background: 'var(--background-color, #222)', color: 'inherit', cursor: 'pointer', fontSize: '12px', whiteSpace: 'nowrap' }
+
+    function relativePath(cwd, path) {
+      if (!cwd) return path
+      const base = cwd.replace(/[\\/]+$/, '').replace(/\\/g, '/')
+      const full = path.replace(/\\/g, '/')
+      return full.toLowerCase().startsWith(`${base.toLowerCase()}/`) ? full.slice(base.length + 1) : path
+    }
+
+    function lineNumber(source, index) {
+      return source.slice(0, index).split('\n').length
+    }
+
+    function selectionInsert(path, cwd, source, start, end) {
+      const selected = source.slice(start, end)
+      const first = lineNumber(source, start)
+      const last = lineNumber(source, Math.max(start, end - 1))
+      const rel = relativePath(cwd, path)
+      const header = last > first ? `${rel}:${first}-${last}` : `${rel}:${first}`
+      return selected.length > 500 ? header : '```' + header + '\n' + selected + '\n```'
+    }
+
+    function appendToConversation(ctx, sessionId, text) {
+      try {
+        const scope = ctx?.sessions?.scope?.(sessionId)
+        const conversation = ctx?.get?.('conversation')
+        if (!scope || !conversation) return false
+        const input = conversation.input.for(scope)
+        const draft = input.state.getSnapshot().draft
+        input.setDraft(draft.trim() ? `${draft} ${text}` : text)
+        return true
+      } catch (error) {
+        console.warn('[dsh-autodetect] 添加选区到对话失败:', error)
+        return false
+      }
+    }
+
+    function endpoint(path, scope) {
+      const params = new URLSearchParams({ sessionId: scope.sessionId, path })
+      if (scope.cwd) params.set('cwd', scope.cwd)
+      return `/autodetect/api/read?${params}`
+    }
+
+    function addressInfo(address) {
+      try {
+        const url = new URL(address)
+        const parts = url.pathname.split('/').filter(Boolean)
+        if (url.protocol !== 'dsh-resource:' || url.hostname !== 'file' || parts[0] !== 'session' || parts.length < 3) return null
+        const sessionId = decodeURIComponent(parts[1])
+        let path = decodeURIComponent(parts.slice(2).join('/'))
+        if (/^\/[A-Za-z]:[\\/]/.test(path)) path = path.slice(1)
+        return { sessionId, path }
+      } catch {
+        return null
+      }
+    }
+
+    function titleForAddress(address) {
+      const info = addressInfo(address)
+      if (!info) return 'AutoDetect'
+      const parts = info.path.replace(/\\/g, '/').split('/').filter(Boolean)
+      return parts[parts.length - 1] || info.path
+    }
+
+    async function load(path, scope, signal) {
+      const response = await fetch(endpoint(path, scope), { signal })
+      const value = await response.json()
+      if (!response.ok) throw new Error(value.error || `HTTP ${response.status}`)
+      return value
+    }
+
+    function AutoDetectView(props) {
+      const data = props.customData || {}
+      const [content, setContent] = useState(data.content || '')
+      const [dirty, setDirty] = useState(false)
+      const [saveState, setSaveState] = useState('idle')
+      const [selection, setSelection] = useState(null)
+      const editorRef = useRef(null)
+      const gutterRef = useRef(null)
+      const popupRef = useRef(null)
+      const selectionButtonRef = useRef(null)
+      const lastDragPointRef = useRef(null)
+      const lockedMousePointRef = useRef(null)
+      const meta = useMemo(() => `${data.encoding || 'unknown'}${data.bom ? ' + BOM' : ''} · ${data.newline || 'lf'}`, [data])
+
+      const hideSelection = () => {
+        popupRef.current = null
+        setSelection(null)
+      }
+
+      const showSelection = (insert, point, anchor = 'direct') => {
+        const next = {
+          insert,
+          left: point.left,
+          top: point.top,
+          anchorLeft: point.left,
+          anchorTop: point.top,
+          anchor,
+        }
+        popupRef.current = next
+        setSelection(next)
+      }
+
+      useLayoutEffect(() => {
+        if (!selection) return
+        const rect = selectionButtonRef.current?.getBoundingClientRect()
+        if (!rect) return
+        const edge = 8
+        const anchorLeft = selection.anchor === 'mouse' ? selection.anchorLeft - rect.width / 2 : selection.anchorLeft
+        const anchorTop = selection.anchor === 'mouse' ? selection.anchorTop - rect.height - selectionButtonGap : selection.anchorTop
+        const next = {
+          ...selection,
+          left: Math.min(Math.max(edge, anchorLeft), Math.max(edge, window.innerWidth - rect.width - edge)),
+          top: Math.min(Math.max(edge, anchorTop), Math.max(edge, window.innerHeight - rect.height - edge)),
+        }
+        if (next.left === selection.left && next.top === selection.top) return
+        popupRef.current = next
+        setSelection(next)
+      }, [selection?.insert, selection?.anchor, selection?.anchorLeft, selection?.anchorTop])
+
+      const save = async () => {
+        if (saveState === 'saving') return
+        setSaveState('saving')
+        try {
+          const response = await fetch('/autodetect/api/write', {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({ sessionId: props.scope.sessionId, cwd: props.scope.cwd, path: props.path, content, encoding: data.encoding, bom: data.bom, newline: data.newline, expectedSha256: data.sha256 }),
+          })
+          const value = await response.json()
+          if (!response.ok) throw new Error(value.error || `HTTP ${response.status}`)
+          setDirty(false)
+          setSaveState('saved')
+        } catch (error) {
+          setSaveState(`failed: ${error instanceof Error ? error.message : String(error)}`)
+        }
+      }
+
+      useEffect(() => {
+        props.onToolbarState?.({ modes: false, mode: 'edit', dirty, editable: !data.binary, saveState: saveState.startsWith('failed') ? 'failed' : saveState })
+        props.onToolbarControls?.({ setMode: () => {}, save })
+        return () => props.onToolbarControls?.(null)
+      }, [dirty, saveState, data.binary])
+
+      const updateSelection = (event) => {
+        const editor = editorRef.current
+        const browserSelection = window.getSelection()
+        if (!editor || !browserSelection || browserSelection.rangeCount === 0 || browserSelection.isCollapsed) {
+          hideSelection()
+          return
+        }
+        const range = browserSelection.getRangeAt(0)
+        if (!editor.contains(range.startContainer) || !editor.contains(range.endContainer)) {
+          hideSelection()
+          return
+        }
+        const before = document.createRange()
+        before.selectNodeContents(editor)
+        before.setEnd(range.startContainer, range.startOffset)
+        const selected = browserSelection.toString()
+        const start = before.toString().length
+        const end = start + selected.length
+        if (!selected.trim()) {
+          hideSelection()
+          return
+        }
+        const rect = range.getBoundingClientRect()
+        const hasMousePoint = (event?.type === 'mouseup' || event?.type === 'mousemove') && Number.isFinite(event.clientX) && Number.isFinite(event.clientY)
+        const lockedPoint = lockedMousePointRef.current
+        const mousePoint = hasMousePoint || Boolean(lockedPoint)
+        const point = mousePoint
+          ? (hasMousePoint ? { left: event.clientX, top: event.clientY } : lockedPoint)
+          : rect && (rect.width > 0 || rect.height > 0)
+            ? { left: rect.right, top: rect.bottom + 8 }
+            : { left: 12, top: 12 }
+        showSelection(selectionInsert(props.path, props.scope?.cwd, content, start, end), point, mousePoint ? 'mouse' : 'direct')
+      }
+
+      const addSelection = () => {
+        const current = popupRef.current
+        if (!current) return
+        if (appendToConversation(props.ctx, props.scope?.sessionId, current.insert)) hideSelection()
+      }
+
+      useEffect(() => {
+        if (!selection) return
+        const close = () => hideSelection()
+        const onMouseDown = (event) => {
+          if (event.target instanceof Node && selectionButtonRef.current?.contains(event.target)) return
+          close()
+        }
+        const onKeyDown = (event) => {
+          if (event.key === 'Escape') close()
+        }
+        const onSelectionChange = () => {
+          const browserSelection = window.getSelection()
+          if (!browserSelection || browserSelection.isCollapsed || browserSelection.toString().trim() === '') {
+            close()
+            return
+          }
+          const range = browserSelection.rangeCount > 0 ? browserSelection.getRangeAt(0) : null
+          if (!range || !editorRef.current?.contains(range.startContainer) || !editorRef.current?.contains(range.endContainer)) close()
+        }
+        const onVisibilityChange = () => {
+          if (document.visibilityState !== 'visible') close()
+        }
+        window.addEventListener('mousedown', onMouseDown)
+        window.addEventListener('resize', close)
+        window.addEventListener('blur', close)
+        window.addEventListener('keydown', onKeyDown)
+        document.addEventListener('selectionchange', onSelectionChange)
+        document.addEventListener('visibilitychange', onVisibilityChange)
+        return () => {
+          window.removeEventListener('mousedown', onMouseDown)
+          window.removeEventListener('resize', close)
+          window.removeEventListener('blur', close)
+          window.removeEventListener('keydown', onKeyDown)
+          document.removeEventListener('selectionchange', onSelectionChange)
+          document.removeEventListener('visibilitychange', onVisibilityChange)
+        }
+      }, [selection])
+
+      useEffect(() => {
+        hideSelection()
+      }, [props.path, props.scope?.sessionId])
+
+      const syncGutter = () => {
+        if (editorRef.current && gutterRef.current) gutterRef.current.scrollTop = editorRef.current.scrollTop
+        hideSelection()
+      }
+
+      const handleMouseMove = (event) => {
+        if (!(event.buttons & 1)) return
+        const point = { left: event.clientX, top: event.clientY }
+        lastDragPointRef.current = point
+        lockedMousePointRef.current = point
+        updateSelection(event)
+      }
+
+      const handleMouseUp = (event) => {
+        const lastPoint = lastDragPointRef.current
+        lastDragPointRef.current = null
+        if (lastPoint) {
+          lockedMousePointRef.current = lastPoint
+          return
+        }
+        updateSelection(event)
+      }
+
+      const handleMouseDown = () => {
+        lastDragPointRef.current = null
+        lockedMousePointRef.current = null
+      }
+
+      if (data.binary) {
+        return React.createElement('div', { style }, React.createElement('div', { style: barStyle }, 'AutoDetect · 检测为二进制文件，已禁用编辑'))
+      }
+
+      return React.createElement('div', { style },
+        props.toolbar !== 'host' && React.createElement('div', { style: barStyle },
+          React.createElement('span', null, `AutoDetect · ${meta}`),
+          React.createElement('button', { type: 'button', onClick: save, disabled: !dirty || saveState === 'saving' }, '保存'),
+          saveState === 'saved' && React.createElement('span', null, '已保存'),
+          saveState.startsWith('failed') && React.createElement('span', null, saveState),
+        ),
+        selection && createPortal(
+          React.createElement('button', { ref: selectionButtonRef, type: 'button', style: { ...selectionButtonStyle, left: selection.left, top: selection.top }, onMouseDown: (event) => { event.preventDefault() }, onClick: addSelection }, '添加到对话'),
+          document.body,
+        ),
+        React.createElement('div', { style: editorLayoutStyle },
+          React.createElement('div', { ref: gutterRef, 'aria-hidden': true, style: gutterStyle }, content.split('\n').map((_, index) => `${index + 1}\n`).join('')),
+          React.createElement('div', { ref: editorRef, contentEditable: true, suppressContentEditableWarning: true, spellCheck: false, role: 'textbox', tabIndex: 0, onMouseDown: handleMouseDown, onMouseMove: handleMouseMove, onMouseUp: handleMouseUp, onKeyUp: updateSelection, onScroll: syncGutter, onInput: (event) => { setContent(event.currentTarget.textContent || ''); setDirty(true); updateSelection() }, style: editorStyle }, content),
+        ),
+      )
+    }
+
+    function apply(ctx) {
+      function OfficialAutoDetectView(props) {
+        const { tab } = props.useTabInfo()
+        const address = tab.navigation.address
+        const info = useMemo(() => addressInfo(address), [address])
+        const [state, setState] = useState({ address: null, status: 'loading', data: null, error: null })
+
+        useEffect(() => {
+          if (!info) {
+            setState({ address, status: 'error', data: null, error: new Error('无法解析官方资源地址') })
+            return undefined
+          }
+          const controller = new AbortController()
+          const onTabAbort = () => controller.abort()
+          if (tab.signal.aborted) controller.abort()
+          else tab.signal.addEventListener('abort', onTabAbort, { once: true })
+          setState({ address, status: 'loading', data: null, error: null })
+          load(info.path, { sessionId: info.sessionId }, controller.signal)
+            .then((data) => { if (!controller.signal.aborted) setState({ address, status: 'ready', data, error: null }) })
+            .catch((error) => { if (!controller.signal.aborted) setState({ address, status: 'error', data: null, error }) })
+          return () => {
+            tab.signal.removeEventListener('abort', onTabAbort)
+            controller.abort()
+          }
+        }, [address, info?.path, info?.sessionId, tab.signal])
+
+        if (state.address !== address || state.status === 'loading') return React.createElement('div', { style: { padding: '16px', fontFamily: 'system-ui, sans-serif' } }, '正在读取文件…')
+        if (state.status === 'error') return React.createElement('div', { style: { padding: '16px', color: '#c62828', fontFamily: 'system-ui, sans-serif', whiteSpace: 'pre-wrap' } }, `读取失败：${state.error instanceof Error ? state.error.message : String(state.error)}`)
+        return React.createElement(AutoDetectView, {
+          ...props,
+          ctx,
+          path: info.path,
+          scope: { sessionId: info.sessionId },
+          customData: state.data,
+          toolbar: 'host',
+        })
+      }
+
+      ctx.effect(() => ctx.sidebarRightTabs.register({
+        id: 'dsh-autodetect',
+        kind: 'dsh-autodetect',
+        patterns: ['dsh-resource://file/**'],
+        priority: 'extension',
+        canOpen: (address) => {
+          const info = addressInfo(address)
+          if (!info) return false
+          const path = info.path.replace(/\\/g, '/').toLowerCase()
+          return EXTENSIONS.some((extension) => path.endsWith(`.${extension}`))
+        },
+        title: titleForAddress,
+      }), 'dsh-autodetect: tab type')
+
+      ctx.effect(() => ctx.slots.inject('sidebar.right.pane.tab', () => ctx.slots.register({
+        name: 'sidebar.right.pane.tab',
+        key: 'dsh-autodetect',
+      }, OfficialAutoDetectView)), 'dsh-autodetect: tab body')
+    }
+
+    return { apply, inject }
+  },
+})

package/lib/index.js

@@ -0,0 +1,128 @@
+import { copyFile, readFile } from 'node:fs/promises'
+import { createHash } from 'node:crypto'
+import { dirname, relative, resolve, sep } from 'node:path'
+import { spawn } from 'node:child_process'
+import { fileURLToPath } from 'node:url'
+
+const ROOT = dirname(fileURLToPath(import.meta.url))
+const HELPER = resolve(ROOT, '..', 'python', 'autodetect_codec.py')
+const MAX_BODY = 12 * 1024 * 1024
+const name = 'dsh-autodetect'
+const inject = ['webServer', 'sessions']
+
+function json(res, status, value) {
+  res.writeHead(status, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' })
+  res.end(JSON.stringify(value))
+}
+
+async function requestBody(req) {
+  const chunks = []
+  let size = 0
+  for await (const chunk of req) {
+    const buffer = Buffer.from(chunk)
+    size += buffer.length
+    if (size > MAX_BODY) throw new Error('request body is too large')
+    chunks.push(buffer)
+  }
+  return Buffer.concat(chunks).toString('utf8')
+}
+
+function pythonCommand() {
+  const configured = process.env.AUTODETECT_PYTHON
+  if (configured) return { command: configured, args: [] }
+  if (process.platform === 'win32') {
+    // The Windows Store `python.exe` alias may shadow the real interpreter.
+    // Use the Python launcher so the installed charset-normalizer environment
+    // is selected consistently; AUTODETECT_PYTHON still overrides this.
+    return { command: 'py', args: ['-3'] }
+  }
+  return { command: 'python3', args: [] }
+}
+
+function runCodec(payload) {
+  return new Promise((resolvePromise, reject) => {
+    const python = pythonCommand()
+    const child = spawn(python.command, [...python.args, HELPER], { windowsHide: true, stdio: ['pipe', 'pipe', 'pipe'] })
+    let stdout = ''
+    let stderr = ''
+    child.stdout.setEncoding('utf8')
+    child.stderr.setEncoding('utf8')
+    child.stdout.on('data', (chunk) => { stdout += chunk })
+    child.stderr.on('data', (chunk) => { stderr += chunk })
+    child.once('error', reject)
+    child.once('close', (code) => {
+      if (code !== 0) return reject(new Error(stderr.trim() || `codec exited with ${code}`))
+      try { resolvePromise(JSON.parse(stdout)) } catch (error) { reject(error) }
+    })
+    child.stdin.end(JSON.stringify(payload))
+  })
+}
+
+function sessionCwd(ctx, sessionId, suppliedCwd) {
+  const session = ctx.sessions?.get?.(sessionId)
+  const cwd = session?.header?.cwd || suppliedCwd
+  if (!cwd) throw new Error('session cwd is unavailable')
+  return resolve(cwd)
+}
+
+function safePath(cwd, requested) {
+  const candidate = resolve(cwd, requested)
+  const base = cwd.endsWith(sep) ? cwd : `${cwd}${sep}`
+  if (candidate !== cwd && !candidate.startsWith(base) && !candidate.toLowerCase().startsWith(base.toLowerCase())) {
+    throw new Error('path is outside the session workspace')
+  }
+  return candidate
+}
+
+async function handleRead(ctx, req, res, url) {
+  const cwd = sessionCwd(ctx, url.searchParams.get('sessionId'), url.searchParams.get('cwd'))
+  const path = safePath(cwd, url.searchParams.get('path') || '')
+  const result = await runCodec({ action: 'read', path })
+  json(res, 200, result)
+}
+
+async function handleWrite(ctx, req, res) {
+  const payload = JSON.parse(await requestBody(req))
+  const cwd = sessionCwd(ctx, payload.sessionId, payload.cwd)
+  const path = safePath(cwd, payload.path || '')
+  const original = await readFile(path)
+  const currentSha256 = createHash('sha256').update(original).digest('hex')
+  if (payload.expectedSha256 && payload.expectedSha256 !== currentSha256) {
+    const error = new Error('file changed on disk; reload before saving')
+    error.statusCode = 409
+    throw error
+  }
+  const backup = `${path}.autodetect.bak`
+  await copyFile(path, backup)
+  const result = await runCodec({
+    action: 'write',
+    path,
+    content: payload.content || '',
+    encoding: payload.encoding,
+    bom: payload.bom,
+    newline: payload.newline,
+    expectedSha256: currentSha256,
+  })
+  json(res, 200, { ...result, backup })
+}
+
+function apply(ctx) {
+  console.error('[dsh-autodetect] host apply')
+  if (!ctx.webServer?.register) return
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'prefix',
+    path: '/autodetect/api',
+    handler: async (req, res) => {
+      try {
+        const url = new URL(req.url || '/', 'http://dsh.internal')
+        if (req.method === 'GET' && url.pathname === '/autodetect/api/read') return await handleRead(ctx, req, res, url)
+        if (req.method === 'POST' && url.pathname === '/autodetect/api/write') return await handleWrite(ctx, req, res)
+        json(res, 405, { error: 'method not allowed' })
+      } catch (error) {
+        json(res, error?.statusCode || 400, { error: error instanceof Error ? error.message : String(error) })
+      }
+    },
+  }), 'dsh-autodetect: routes')
+}
+
+export { apply, inject, name }

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "dsh-autodetect",
+  "version": "0.1.0",
+  "description": "Encoding-safe Windows script viewer for the official DSH sidebar",
+  "keywords": [
+    "deepseek",
+    "harness",
+    "dsh",
+    "plugin",
+    "sidebar",
+    "encoding",
+    "windows"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Xiaoph123/dsh-autodetect.git"
+  },
+  "homepage": "https://github.com/Xiaoph123/dsh-autodetect#readme",
+  "bugs": {
+    "url": "https://github.com/Xiaoph123/dsh-autodetect/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "node --test tests/test_package.mjs && py -3 -m unittest discover -s tests",
+    "pack:check": "npm pack --dry-run"
+  },
+  "type": "module",
+  "main": "./lib/index.js",
+  "exports": {
+    ".": "./lib/index.js",
+    "./client": "./lib/client.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib",
+    "python/autodetect_codec.py",
+    "requirements.txt",
+    "README.md"
+  ],
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "inject": [
+        "@deepseek-ai/dsh-client-runtime",
+        "@deepseek-ai/dsh-client-ui-slots",
+        "@deepseek-ai/dsh-client-ui-sidebar-right"
+      ],
+      "platform": "web"
+    }
+  },
+  "peerDependencies": {
+    "@deepseek-ai/dsh-client-runtime": "*",
+    "@deepseek-ai/dsh-client-ui-sidebar-right": "*",
+    "@deepseek-ai/dsh-client-ui-slots": "*",
+    "react": "^18.2.0"
+  },
+  "dependencies": {
+    "react": "^18.2.0"
+  }
+}

package/python/autodetect_codec.py

@@ -0,0 +1,207 @@
+#!/usr/bin/env python3
+"""Binary-safe Windows text detection and round-trip encoding helper."""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import json
+import re
+import sys
+import tempfile
+from pathlib import Path
+
+from charset_normalizer import from_bytes
+
+
+if hasattr(sys.stdin, "reconfigure"):
+    sys.stdin.reconfigure(encoding="utf-8", errors="strict")
+if hasattr(sys.stdout, "reconfigure"):
+    sys.stdout.reconfigure(encoding="utf-8", errors="strict")
+
+
+BOMS = (
+    (b"\xff\xfe\x00\x00", "utf-32-le"),
+    (b"\x00\x00\xfe\xff", "utf-32-be"),
+    (b"\xff\xfe", "utf-16-le"),
+    (b"\xfe\xff", "utf-16-be"),
+    (b"\xef\xbb\xbf", "utf-8"),
+)
+
+SUPPORTED_TEXT_EXTENSIONS = {".bat", ".cmd", ".ini", ".vbs", ".ps1"}
+COMMON_ENCODINGS = {"utf-8", "gbk", "gb18030", "utf-16-le", "utf-16-be", "utf-32-le", "utf-32-be", "cp1252", "shift-jis"}
+
+
+def detect(data: bytes) -> tuple[str, bool, bytes]:
+    for marker, encoding in BOMS:
+        if data.startswith(marker):
+            return encoding, True, data[len(marker):]
+    if not data:
+        return "utf-8", False, data
+    if _is_valid(data, "utf-8"):
+        return "utf-8", False, data
+    # A BOM-less UTF-16 file can otherwise look like valid UTF-8 containing NULs.
+    for encoding in ("utf-16-le", "utf-16-be"):
+        if _looks_like_bomless_utf16(data, encoding):
+            return encoding, False, data
+    # GBK is a strict subset of GB18030. Prefer GBK when the bytes round-trip
+    # through it; only use GB18030 when the file contains four-byte sequences
+    # that GBK cannot represent.
+    if _is_valid(data, "gbk"):
+        return "gbk", False, data
+    if _is_valid(data, "gb18030"):
+        return "gb18030", False, data
+    match = from_bytes(data).best()
+    detected = (match.encoding if match else "utf-8").lower().replace("_", "-")
+    aliases = {
+        "cp936": "gbk",
+        "ms936": "gbk",
+        "gb2312": "gb18030",
+        "ascii": "utf-8",
+        "932": "shift-jis",
+        "sjis": "shift-jis",
+        "windows-1252": "cp1252",
+    }
+    encoding = aliases.get(detected, detected)
+    if encoding not in COMMON_ENCODINGS:
+        encoding = "utf-8"
+    return encoding, False, data
+
+
+def _is_valid(data: bytes, encoding: str) -> bool:
+    try:
+        text = data.decode(encoding, errors="strict")
+        return text.encode(encoding, errors="strict") == data
+    except UnicodeError:
+        return False
+
+
+def _looks_like_bomless_utf16(data: bytes, encoding: str) -> bool:
+    if len(data) < 16 or len(data) % 2:
+        return False
+    even_nuls = sum(data[index] == 0 for index in range(0, len(data), 2))
+    odd_nuls = sum(data[index] == 0 for index in range(1, len(data), 2))
+    half = len(data) // 2
+    skewed = (encoding == "utf-16-le" and odd_nuls * 10 >= half * 3 and even_nuls * 20 <= half) or (encoding == "utf-16-be" and even_nuls * 10 >= half * 3 and odd_nuls * 20 <= half)
+    if not skewed:
+        return False
+    try:
+        text = data.decode(encoding, errors="strict")
+        return "\ufffd" not in text
+    except UnicodeError:
+        return False
+
+
+def is_binary(data: bytes, encoding: str, bom: bool) -> bool:
+    if not data:
+        return False
+    if encoding.startswith("utf-16") or encoding.startswith("utf-32"):
+        return False
+    if b"\x00" in data:
+        return True
+    controls = sum(byte < 8 or 14 <= byte < 32 for byte in data)
+    return controls / len(data) > 0.02
+
+
+def newline_of(text: str) -> str:
+    match = re.search(r"\r\n|\r|\n", text)
+    return {"\r\n": "crlf", "\r": "cr", "\n": "lf"}.get(match.group(0), "lf") if match else "lf"
+
+
+def to_editor_text(text: str) -> str:
+    return text.replace("\r\n", "\n").replace("\r", "\n")
+
+
+def encode_text(content: str, encoding: str, bom: bool, newline: str) -> bytes:
+    separator = {"crlf": "\r\n", "cr": "\r", "lf": "\n"}.get(newline, "\n")
+    normalized = content.replace("\r\n", "\n").replace("\r", "\n")
+    text = normalized.replace("\n", separator)
+    raw = text.encode(encoding, errors="strict")
+    if bom:
+        marker = {
+            "utf-8": b"\xef\xbb\xbf",
+            "utf-16-le": b"\xff\xfe",
+            "utf-16-be": b"\xfe\xff",
+            "utf-32-le": b"\xff\xfe\x00\x00",
+            "utf-32-be": b"\x00\x00\xfe\xff",
+        }.get(encoding, b"")
+        raw = marker + raw
+    return raw
+
+
+def read_file(path: Path) -> dict[str, object]:
+    data = path.read_bytes()
+    encoding, bom, body = detect(data)
+    binary = is_binary(data, encoding, bom)
+    if binary:
+        return {
+            "content": "",
+            "encoding": encoding,
+            "bom": bom,
+            "newline": "lf",
+            "size": len(data),
+            "sha256": hashlib.sha256(data).hexdigest(),
+            "binary": True,
+            "extension": path.suffix.lower(),
+        }
+    text = body.decode(encoding, errors="strict")
+    return {
+        "content": to_editor_text(text),
+        "encoding": encoding,
+        "bom": bom,
+        "newline": newline_of(text),
+        "size": len(data),
+        "sha256": hashlib.sha256(data).hexdigest(),
+        "binary": binary,
+        "extension": path.suffix.lower(),
+    }
+
+
+def atomic_write(path: Path, data: bytes) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with tempfile.NamedTemporaryFile(dir=path.parent, prefix=f".{path.name}.", suffix=".tmp", delete=False) as file:
+        temporary = Path(file.name)
+        file.write(data)
+        file.flush()
+        import os
+        os.fsync(file.fileno())
+    try:
+        temporary.replace(path)
+    finally:
+        temporary.unlink(missing_ok=True)
+
+
+def main(payload: dict[str, object]) -> dict[str, object]:
+    action = payload.get("action")
+    if action == "read":
+        path = Path(str(payload["path"]))
+        if path.suffix.lower() not in SUPPORTED_TEXT_EXTENSIONS:
+            raise ValueError(f"unsupported file extension: {path.suffix or '<none>'}")
+        return read_file(path)
+    if action == "encode":
+        raw = encode_text(str(payload.get("content", "")), str(payload.get("encoding", "utf-8")), bool(payload.get("bom", False)), str(payload.get("newline", "lf")))
+        return {"bytes": base64.b64encode(raw).decode("ascii"), "size": len(raw)}
+    if action == "write":
+        path = Path(str(payload["path"]))
+        if path.suffix.lower() not in SUPPORTED_TEXT_EXTENSIONS:
+            raise ValueError(f"unsupported file extension: {path.suffix or '<none>'}")
+        current = path.read_bytes()
+        expected = str(payload.get("expectedSha256", ""))
+        actual = hashlib.sha256(current).hexdigest()
+        if expected and expected != actual:
+            raise RuntimeError("file changed on disk; reload before saving")
+        raw = encode_text(str(payload.get("content", "")), str(payload.get("encoding", "utf-8")), bool(payload.get("bom", False)), str(payload.get("newline", "lf")))
+        atomic_write(path, raw)
+        return {"ok": True, "size": len(raw), "sha256": hashlib.sha256(raw).hexdigest()}
+    raise ValueError(f"unknown action: {action}")
+
+
+if __name__ == "__main__":
+    try:
+        request = json.load(sys.stdin)
+        # Keep the JSON transport ASCII-only so it is independent of the
+        # Windows console code page used by the hosting Python process.
+        json.dump(main(request), sys.stdout, ensure_ascii=True)
+    except Exception as error:
+        print(f"{type(error).__name__}: {error}", file=sys.stderr)
+        raise SystemExit(1)

package/requirements.txt

@@ -0,0 +1 @@
+charset-normalizer>=3.4,<4