dsh-linked-workspace 0.5.13 → 0.6.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 0.6.0 — 2026-11-05
+
+- **Document editing in the content panel** for Markdown, PDF, DOCX, XLSX and PPTX, on both local and remote files.
+  - Markdown: raw editing, rendered preview, export to PDF.
+  - DOCX: paragraph and table text editing (styles are preserved at paragraph level; rich inline formatting may be simplified).
+  - XLSX: sheet tabs and editable cell grid; formulas and untouched styles are preserved.
+  - PPTX: slide navigation and text-frame editing.
+  - PDF: page navigation, rotate/delete page, title/author metadata; page images are rendered by PyMuPDF.
+- New document files can be created from the directory context menu (`.md`, `.pdf`, `.docx`, `.xlsx`, `.pptx`).
+- A small Python bridge (`scripts/doc_tool.py`) implements the format-specific read/write/create operations. Python 3 with `python-docx`, `openpyxl`, `python-pptx` and `PyMuPDF` is required for Office/PDF operations; Markdown works without them.
+- Runs on both local folders and remote linked/directories (remote files are downloaded, processed and uploaded atomically).
+
 ## 0.5.13 — 2026-11-05
 
 - The linked-workspace directory panel can now be resized by dragging the divider; double-click the divider to reset to 300 px. The width is persisted.

package/README.en.md

@@ -28,6 +28,18 @@ The plugin takes over the directory-selection hole used by the DSH sidebar and e
 1. **Local workspace**: enter or browse for a local directory (C:/D:/E: drive chips on Windows), set a workspace name, then create a normal DSH workspace.
 2. **Linked workspace**: SSH host + remote folder + local folder + optional mirror. Creating it also registers the local folder as a DSH workspace. The local directory is **not** pre-populated with `.local`/`.remote`; those are created lazily when mirroring or transfers need them.
 
+### Document editing
+
+The content panel now edits **Markdown / PDF / DOCX / XLSX / PPTX** files on both local and remote sides:
+
+- **Markdown**: raw editing, rendered preview, export to PDF.
+- **DOCX**: edit paragraph and table text; paragraph styles are kept, complex inline formatting may be simplified.
+- **XLSX**: switch sheets and edit a cell grid; untouched formulas and styles are preserved.
+- **PPTX**: navigate slides and edit text frames.
+- **PDF**: page navigation, rotate/delete pages, and title/author metadata; pages are rendered by PyMuPDF.
+- Create blank documents from the directory context menu by using one of these extensions.
+- Office/PDF operations need Python 3 with `python-docx`, `openpyxl`, `python-pptx` and `PyMuPDF`; Markdown does not. Set `DSH_OFFICE_PYTHON` to choose an interpreter.
+
 ### Right-sidebar entries
 
 - **Linked workspace directory**: appears only in sessions of a linked workspace, and opens the linked workspace bound to that session. Remote and local files are editable.
@@ -82,7 +94,13 @@ The remote side is not modified by mirroring. The `linked_workspace` tool suppor
 
 ## Installation
 
+```bash
+dsh plugin --profile web add dsh-linked-workspace
 ```
+
+Install from source (development):
+
+```bash
 dsh plugin --profile "$DSH_PROFILE" add "file:$PWD/dsh-linked-workspace"
 ```
 

package/README.md

@@ -29,6 +29,18 @@
 
 > 左侧工作区行不再带 `⇄` 标题前缀：插件用一份按 `data-row-key` 定位的样式表，把联动工作区行的宿主文件夹图标替换成**链环图标**（普通本地工作区不受影响）。这是对宿主行结构的唯一 DOM 级适配；如果 DSH 以后更改行结构，选择器会自然失配并回退到原来的文件夹图标，不破坏其他功能。
 
+### 文档创建与编辑
+
+文件内容面板现在支持 **Markdown / PDF / DOCX / XLSX / PPTX**（本地与远程文件均可）：
+
+- **Markdown**：原始文本编辑、渲染预览、导出 PDF。
+- **DOCX**：按段落与表格编辑文字；保留段落样式，复杂行内格式可能被简化。
+- **XLSX**：工作表切换与单元格网格编辑；未修改的公式与样式保留。
+- **PPTX**：幻灯片切换与文本框编辑。
+- **PDF**：翻页、旋转/删除页面、编辑标题/作者元数据；页面由 PyMuPDF 渲染。
+- 在目录右键「新建文件」中输入支持的扩展名即可创建对应空白文档。
+- Office/PDF 操作需要 Python 3 及 `python-docx`、`openpyxl`、`python-pptx`、`PyMuPDF`；Markdown 不依赖 Python。可通过 `DSH_OFFICE_PYTHON` 指定解释器。
+
 ### 右侧栏入口
 
 - **联动工作区目录**：只在联动工作区的会话中出现；点开后绑定该会话对应的联动工作区（不会打开另一个联动工作区），可编辑远程与本地文件。

package/docs/API.md

@@ -16,6 +16,16 @@ Codes: `BAD_REQUEST`, `NOT_FOUND`, `SSH_CONNECT`, `AUTH_FAILED`,
 `HOST_KEY_MISMATCH`, `TIMEOUT`, `FS_NOT_FOUND`, `FS_PERMISSION`, `FS_IS_DIR`,
 `FS_NOT_DIR`, `FS_TOO_LARGE`, `CONFLICT`, `INTERNAL`.
 
+## Document APIs
+
+| Method | Params | Result |
+| --- | --- | --- |
+| `docs.read` | `{ path, linkedId?, workspaceId? }` | kind-specific document model |
+| `docs.write` | `{ path, data, expectedMtime?, linkedId?, workspaceId? }` | `{ kind, path, size, mtime }` |
+| `docs.create` | `{ path, kind?, linkedId?, workspaceId? }` | `{ kind, path, size, mtime }` |
+| `docs.mdPreview` | `{ path, text?, linkedId?, workspaceId? }` | `{ kind, html }` |
+| `docs.mdPdf` | `{ path, text?, linkedId?, workspaceId? }` | `{ kind: "pdf", path, size, mtime }` |
+
 ## Records
 
 ```ts

package/lib/client.js

@@ -2058,6 +2058,21 @@ function fileIconSpec(name, isDir) {
       toggleDirectory: '开启/关闭联动工作区目录面板',
       closeFile: '关闭文件标签',
       resizeDirectory: '拖动调整目录面板宽度；双击恢复默认宽度',
+      docPreview: '预览',
+      docEdit: '编辑',
+      exportPdf: '导出 PDF',
+      docPages: '页',
+      docRotate: '旋转 90°',
+      docDeletePage: '删除当前页',
+      docParagraph: '段落',
+      docTable: '表格',
+      docSheet: '工作表',
+      docSlide: '幻灯片',
+      docPdfTitle: '标题',
+      docPdfAuthor: '作者',
+      docPageOf: '第 {page} / {total} 页',
+      docExportDone: '已导出 PDF：{path}',
+      docPreviewFailed: '预览失败',
       remoteTabTitle: '远程目录',
       remoteTabDesc: '只读查看已添加的远程目录及其文件，不允许编辑。',
       remoteDirsTitle: '远程目录',
@@ -2333,6 +2348,21 @@ function fileIconSpec(name, isDir) {
       toggleDirectory: 'Show or hide the linked workspace directory panel',
       closeFile: 'Close file tab',
       resizeDirectory: 'Drag to resize the directory panel; double-click to reset',
+      docPreview: 'Preview',
+      docEdit: 'Edit',
+      exportPdf: 'Export PDF',
+      docPages: 'pages',
+      docRotate: 'Rotate 90°',
+      docDeletePage: 'Delete current page',
+      docParagraph: 'Paragraph',
+      docTable: 'Table',
+      docSheet: 'Sheet',
+      docSlide: 'Slide',
+      docPdfTitle: 'Title',
+      docPdfAuthor: 'Author',
+      docPageOf: 'Page {page} / {total}',
+      docExportDone: 'Exported PDF: {path}',
+      docPreviewFailed: 'Preview failed',
       remoteTabTitle: 'Remote directories',
       remoteTabDesc: 'Read-only view of configured remote directories and files; editing is disabled.',
       remoteDirsTitle: 'Remote directories',
@@ -2589,6 +2619,35 @@ function fileIconSpec(name, isDir) {
       return error.message || String(error);
     }
 
+    function documentKindOf(path) {
+      var ext = String(path || '').toLowerCase().match(/\.[^./\\]+$/);
+      if (!ext) return '';
+      var value = ext[0];
+      if (value === '.md' || value === '.markdown') return 'markdown';
+      if (value === '.pdf') return 'pdf';
+      if (value === '.docx') return 'docx';
+      if (value === '.xlsx') return 'xlsx';
+      if (value === '.pptx') return 'pptx';
+      return '';
+    }
+
+    function sanitizeDocumentHtml(html) {
+      try {
+        var parsed = new DOMParser().parseFromString(String(html || ''), 'text/html');
+        parsed.querySelectorAll('script,style,iframe,object,embed,link,meta,base,form').forEach(function (node) { node.remove(); });
+        parsed.querySelectorAll('*').forEach(function (element) {
+          Array.from(element.attributes).forEach(function (attribute) {
+            if (/^on/i.test(attribute.name) || /^javascript:/i.test(attribute.value) || /^data:text\/html/i.test(attribute.value)) {
+              element.removeAttribute(attribute.name);
+            }
+          });
+        });
+        return parsed.body.innerHTML;
+      } catch (error) {
+        return '';
+      }
+    }
+
     function basename(path) {
       if (!path) return '';
       var clean = path.replace(/[\\/]+$/, '');
@@ -2938,6 +2997,35 @@ function fileIconSpec(name, isDir) {
       '.rw-content-pane{display:flex;flex-direction:column;flex:1 1 auto;min-width:0;min-height:0}',
       '.rw-directory-pane{display:flex;flex-direction:column;flex:0 0 auto;max-width:60%;min-width:240px;min-height:0;border-left:1px solid var(--dsw-alias-border-l1)}',
       '.rw-pane-resizer{flex:0 0 6px;align-self:stretch;cursor:col-resize;background:transparent;position:relative;z-index:2;touch-action:none}',
+      '.rw-doc{display:flex;flex-direction:column;flex:1 1 auto;min-height:0;min-width:0;background:var(--dsw-alias-bg-base)}',
+      '.rw-doc-toolbar{display:flex;align-items:center;gap:6px;padding:6px 8px;border-bottom:1px solid var(--dsw-alias-border-l1);background:var(--dsw-alias-bg-layer-1);flex:none;flex-wrap:wrap}',
+      '.rw-doc-body{display:flex;flex-direction:column;flex:1 1 auto;min-height:0;overflow:auto;padding:10px}',
+      '.rw-doc-textarea{width:100%;min-height:260px;flex:1 1 auto;resize:none;border:1px solid var(--dsw-alias-border-l2);border-radius:8px;padding:10px;background:var(--dsw-alias-bg-layer-1);color:var(--dsw-alias-label-primary);font:12.5px/18px ui-monospace,"Cascadia Code",Consolas,monospace;outline:none;box-sizing:border-box}',
+      '.rw-doc-preview{max-width:920px;margin:0 auto;color:var(--dsw-alias-label-primary);font-size:14px;line-height:1.65;overflow-wrap:anywhere}',
+      '.rw-doc-preview h1,.rw-doc-preview h2,.rw-doc-preview h3{line-height:1.3;margin:1em 0 .5em}',
+      '.rw-doc-preview pre{background:var(--dsw-alias-bg-layer-2);padding:10px;border-radius:8px;overflow:auto}',
+      '.rw-doc-preview table{border-collapse:collapse;margin:.8em 0}',
+      '.rw-doc-preview th,.rw-doc-preview td{border:1px solid var(--dsw-alias-border-l2);padding:5px 8px}',
+      '.rw-doc-preview img{max-width:100%}',
+      '.rw-doc-preview blockquote{border-left:3px solid var(--dsw-alias-border-l2);margin:0;padding-left:10px;color:var(--dsw-alias-label-secondary)}',
+      '.rw-doc-pdf-page{display:block;max-width:100%;margin:0 auto 10px;border:1px solid var(--dsw-alias-border-l2);box-shadow:0 2px 10px rgba(0,0,0,.08);background:#fff}',
+      '.rw-doc-field{display:flex;align-items:center;gap:8px;margin:6px 0}',
+      '.rw-doc-field label{font-size:11.5px;color:var(--dsw-alias-label-tertiary);min-width:38px}',
+      '.rw-doc-input{height:28px;padding:0 8px;border-radius:6px;border:1px solid var(--dsw-alias-border-l2);background:var(--dsw-alias-bg-base);color:var(--dsw-alias-label-primary);font:inherit;font-size:12px;box-sizing:border-box}',
+      '.rw-doc-block{border:1px solid var(--dsw-alias-border-l1);border-radius:8px;padding:7px;margin:0 0 8px;background:var(--dsw-alias-bg-layer-1)}',
+      '.rw-doc-block-label{font-size:10px;line-height:15px;color:var(--dsw-alias-label-tertiary);margin-bottom:3px}',
+      '.rw-doc-block textarea{width:100%;min-height:52px;resize:vertical;border:0;background:transparent;color:var(--dsw-alias-label-primary);font:inherit;font-size:13px;line-height:20px;outline:none;box-sizing:border-box}',
+      '.rw-doc-table{border-collapse:collapse;width:100%;margin:0 0 10px;font-size:12px}',
+      '.rw-doc-table td{border:1px solid var(--dsw-alias-border-l2);padding:0}',
+      '.rw-doc-table input{width:100%;border:0;background:transparent;padding:4px 5px;font:inherit;color:var(--dsw-alias-label-primary);outline:none;box-sizing:border-box}',
+      '.rw-doc-tabs{display:flex;gap:3px;padding:5px;border-bottom:1px solid var(--dsw-alias-border-l1);overflow:auto;flex:none}',
+      '.rw-doc-tab{padding:2px 8px;border:1px solid transparent;border-radius:5px;background:transparent;color:var(--dsw-alias-label-secondary);font:inherit;font-size:11.5px;cursor:pointer;white-space:nowrap}',
+      '.rw-doc-tab.is-on{background:var(--dsw-alias-bg-layer-2);border-color:var(--dsw-alias-border-l2);color:var(--dsw-alias-label-primary)}',
+      '.rw-doc-grid{width:100%;border-collapse:collapse;font-size:11.5px}',
+      '.rw-doc-grid th{position:sticky;top:0;background:var(--dsw-alias-bg-layer-2);font-weight:500;color:var(--dsw-alias-label-tertiary);padding:3px 4px;border:1px solid var(--dsw-alias-border-l1);z-index:1}',
+      '.rw-doc-grid td{border:1px solid var(--dsw-alias-border-l1);padding:0;min-width:60px}',
+      '.rw-doc-grid input{width:100%;border:0;background:transparent;padding:3px 4px;font:inherit;color:var(--dsw-alias-label-primary);outline:none;box-sizing:border-box}',
+      '.rw-doc-status{display:flex;align-items:center;gap:8px;padding:4px 8px;border-top:1px solid var(--dsw-alias-border-l1);font-size:10.5px;color:var(--dsw-alias-label-tertiary);background:var(--dsw-alias-bg-layer-1);flex:none}',
       '.rw-pane-resizer:hover,.rw-pane-resizer:active{background:var(--dsw-alias-brand-primary)}',
       '.rw-directory-head{display:flex;align-items:center;gap:6px;padding:5px 8px;font-size:10.5px;line-height:16px;letter-spacing:.03em;text-transform:uppercase;color:var(--dsw-alias-label-tertiary);background:var(--dsw-alias-bg-layer-1);border-bottom:1px solid var(--dsw-alias-border-l1);flex:none}',
       '.rw-directory-body{display:flex;flex-direction:column;flex:1 1 auto;min-height:0}',
@@ -4319,6 +4407,243 @@ function fileIconSpec(name, isDir) {
           h('button', { type: 'button', className: 'rw-btn rw-btn-sm', onClick: props.onClose }, props.t('close'))));
     }
 
+    function DocumentPane(props) {
+      var ctx = props.ctx;
+      var t = props.t;
+      var locale = props.locale;
+      var scope = props.scope;
+      var path = props.path;
+      var local = props.local === true;
+      var onSaved = props.onSaved;
+      var kind = documentKindOf(path);
+      var stateRef = useState({
+        loading: true, error: '', data: null, text: '', dirty: false, saving: false,
+        preview: false, html: '', previewLoading: false, page: 0, sheet: 0, slide: 0,
+        updates: {}, pptxUpdates: {}, rotations: {}, deleted: {}, notice: '',
+      });
+      var state = stateRef[0];
+      var setState = stateRef[1];
+
+      function patch(next) {
+        setState(function (previous) { return Object.assign({}, previous, next); });
+      }
+
+      function params(extra) {
+        var base = local ? { path: path } : Object.assign({ path: path }, scopeParams(scope));
+        return Object.assign(base, extra || {});
+      }
+
+      function load() {
+        patch({ loading: true, error: '', notice: '' });
+        apiCall('docs.read', params()).then(function (result) {
+          patch({
+            loading: false, error: '', data: result,
+            text: result.kind === 'markdown' ? String(result.text || '') : '',
+            preview: false, html: '', page: 0, sheet: 0, slide: 0,
+            updates: {}, pptxUpdates: {}, rotations: {}, deleted: {}, dirty: false,
+          });
+        }).catch(function (error) {
+          patch({ loading: false, error: messageOf(error, t, locale) });
+        });
+      }
+
+      useEffect(function () { load(); }, [path, local, scope && scope.kind, scope && scope.id]);
+
+      useEffect(function () {
+        if (typeof props.onDirtyChange === 'function') props.onDirtyChange(state.dirty);
+      }, [state.dirty]);
+
+      function save() {
+        if (state.saving) return;
+        patch({ saving: true, error: '', notice: '' });
+        var data = {};
+        if (kind === 'markdown') data = { text: state.text };
+        if (kind === 'docx' && state.data) data = { paragraphs: state.data.paragraphs || [], tables: state.data.tables || [] };
+        if (kind === 'xlsx') data = { updates: Object.keys(state.updates).map(function (key) { return state.updates[key]; }) };
+        if (kind === 'pptx') data = { updates: Object.keys(state.pptxUpdates).map(function (key) { return state.pptxUpdates[key]; }) };
+        if (kind === 'pdf' && state.data) {
+          data = {
+            metadata: state.data.metadata || {},
+            rotations: Object.keys(state.rotations).map(function (index) { return { index: Number(index), degrees: state.rotations[index] }; }),
+            deleted: Object.keys(state.deleted).filter(function (index) { return state.deleted[index]; }).map(Number),
+          };
+        }
+        apiCall('docs.write', params({ data: data, expectedMtime: state.data ? state.data.mtime : undefined })).then(function () {
+          patch({ saving: false, dirty: false, notice: t('saved') });
+          if (onSaved) onSaved();
+          load();
+        }).catch(function (error) {
+          patch({ saving: false, error: messageOf(error, t, locale) });
+        });
+      }
+
+      function showPreview() {
+        var next = !state.preview;
+        patch({ preview: next, previewLoading: next && !state.html });
+        if (!next || state.html) return;
+        apiCall('docs.mdPreview', params({ text: state.text })).then(function (result) {
+          patch({ previewLoading: false, html: sanitizeDocumentHtml(result.html) });
+        }).catch(function (error) {
+          patch({ previewLoading: false, error: messageOf(error, t, locale) });
+        });
+      }
+
+      function exportPdf() {
+        patch({ saving: true, error: '', notice: '' });
+        apiCall('docs.mdPdf', params({ text: state.text })).then(function (result) {
+          patch({ saving: false, notice: t('docExportDone', { path: result.path }) });
+          if (onSaved) onSaved();
+        }).catch(function (error) {
+          patch({ saving: false, error: messageOf(error, t, locale) });
+        });
+      }
+
+      function updateParagraph(index, value) {
+        var data = state.data || {};
+        var paragraphs = (data.paragraphs || []).slice();
+        paragraphs[index] = Object.assign({}, paragraphs[index], { text: value });
+        patch({ data: Object.assign({}, data, { paragraphs: paragraphs }), dirty: true });
+      }
+
+      function updateTableCell(tableIndex, rowIndex, cellIndex, value) {
+        var data = state.data || {};
+        var tables = (data.tables || []).map(function (rows) { return rows.map(function (row) { return row.slice(); }); });
+        if (!tables[tableIndex] || !tables[tableIndex][rowIndex]) return;
+        tables[tableIndex][rowIndex][cellIndex] = value;
+        patch({ data: Object.assign({}, data, { tables: tables }), dirty: true });
+      }
+
+      function updateCell(sheetName, cell, value) {
+        var key = sheetName + '!' + cell;
+        var updates = Object.assign({}, state.updates);
+        updates[key] = { sheet: sheetName, cell: cell, value: value };
+        patch({ updates: updates, dirty: true });
+      }
+
+      function updateSlideText(slideIndex, shapeIndex, value) {
+        var key = slideIndex + ':' + shapeIndex;
+        var updates = Object.assign({}, state.pptxUpdates);
+        updates[key] = { slide: slideIndex, shape: shapeIndex, text: value };
+        patch({ pptxUpdates: updates, dirty: true });
+      }
+
+      var toolbar = h('div', { className: 'rw-doc-toolbar' },
+        h('span', { className: 'rw-chip' }, kind.toUpperCase()),
+        h('span', { className: 'rw-hint', style: { flex: '1 1 auto', overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap' }, title: path }, path),
+        kind === 'markdown' ? h('button', { type: 'button', className: 'rw-btn rw-btn-sm', onClick: showPreview }, state.preview ? t('docEdit') : t('docPreview')) : null,
+        kind === 'markdown' ? h('button', { type: 'button', className: 'rw-btn rw-btn-sm', onClick: exportPdf, disabled: state.saving }, IconDownload(12), t('exportPdf')) : null,
+        h('button', { type: 'button', className: 'rw-btn rw-btn-sm rw-btn-primary', onClick: save, disabled: state.saving || !state.dirty }, state.saving ? Spinner(12) : IconSave(12), state.saving ? t('saving') : t('save')));
+
+      if (state.loading) {
+        return h('div', { className: 'rw-doc' }, toolbar, h('div', { className: 'rw-editor-message' }, Spinner(14), t('loading')));
+      }
+      if (state.error && !state.data) {
+        return h('div', { className: 'rw-doc' }, toolbar,
+          h('div', { className: 'rw-editor-message' },
+            h(Banner, { kind: 'error' }, state.error),
+            h('button', { type: 'button', className: 'rw-btn', onClick: load }, IconRefresh(13), t('reload'))));
+      }
+
+      var body = null;
+      if (kind === 'markdown') {
+        body = state.preview
+          ? h('div', { className: 'rw-doc-body' },
+            state.previewLoading ? h('div', { className: 'rw-editor-message' }, Spinner(14), t('loading')) : null,
+            state.html ? h('div', { className: 'rw-doc-preview', dangerouslySetInnerHTML: { __html: state.html } }) : null)
+          : h('div', { className: 'rw-doc-body' },
+            h('textarea', {
+              className: 'rw-doc-textarea', value: state.text, spellCheck: false,
+              onChange: function (event) { patch({ text: event.currentTarget.value, dirty: true, html: '' }); },
+            }));
+      } else if (kind === 'pdf' && state.data) {
+        var pages = state.data.pages || [];
+        var visible = pages.filter(function (page) { return !state.deleted[page.index]; });
+        var current = visible[Math.min(state.page, Math.max(visible.length - 1, 0))] || null;
+        body = h('div', { className: 'rw-doc-body' },
+          h('div', { className: 'rw-doc-field' },
+            h('label', null, t('docPdfTitle')),
+            h('input', { className: 'rw-doc-input', style: { flex: '1 1 auto' }, value: (state.data.metadata && state.data.metadata.title) || '', onChange: function (event) { patch({ data: Object.assign({}, state.data, { metadata: Object.assign({}, state.data.metadata, { title: event.currentTarget.value }) }), dirty: true }); } }),
+            h('label', null, t('docPdfAuthor')),
+            h('input', { className: 'rw-doc-input', style: { flex: '1 1 auto' }, value: (state.data.metadata && state.data.metadata.author) || '', onChange: function (event) { patch({ data: Object.assign({}, state.data, { metadata: Object.assign({}, state.data.metadata, { author: event.currentTarget.value }) }), dirty: true }); } })),
+          h('div', { className: 'rw-inline', style: { justifyContent: 'space-between', margin: '6px 0' } },
+            h('div', { className: 'rw-inline' },
+              h('button', { type: 'button', className: 'rw-btn rw-btn-sm', disabled: state.page <= 0, onClick: function () { patch({ page: state.page - 1 }); } }, '‹'),
+              h('span', { className: 'rw-hint' }, current ? t('docPageOf', { page: current.index + 1, total: state.data.pageCount }) : ''),
+              h('button', { type: 'button', className: 'rw-btn rw-btn-sm', disabled: state.page >= visible.length - 1, onClick: function () { patch({ page: state.page + 1 }); } }, '›')),
+            h('div', { className: 'rw-inline' },
+              h('button', { type: 'button', className: 'rw-btn rw-btn-sm', disabled: !current, onClick: function () { var rotations = Object.assign({}, state.rotations); rotations[current.index] = ((rotations[current.index] || current.rotation || 0) + 90) % 360; patch({ rotations: rotations, dirty: true }); } }, t('docRotate')),
+              h('button', { type: 'button', className: 'rw-btn rw-btn-sm rw-btn-danger', disabled: !current || visible.length <= 1, onClick: function () { var deleted = Object.assign({}, state.deleted); deleted[current.index] = true; patch({ deleted: deleted, page: Math.max(0, state.page - 1), dirty: true }); } }, t('docDeletePage')))),
+          current ? h('img', { className: 'rw-doc-pdf-page', src: current.png, style: { transform: 'rotate(' + ((state.rotations[current.index] || current.rotation || 0) % 360) + 'deg)' } }) : h('div', { className: 'rw-empty' }, t('noEntries')));
+      } else if (kind === 'docx' && state.data) {
+        var paragraphs = state.data.paragraphs || [];
+        var tables = state.data.tables || [];
+        body = h('div', { className: 'rw-doc-body' },
+          paragraphs.map(function (paragraph, index) {
+            return h('div', { key: 'p' + index, className: 'rw-doc-block' },
+              h('div', { className: 'rw-doc-block-label' }, (paragraph.style || t('docParagraph')) + ' · ' + (index + 1)),
+              h('textarea', { value: paragraph.text || '', onChange: function (event) { updateParagraph(index, event.currentTarget.value); } }));
+          }),
+          tables.map(function (rows, tableIndex) {
+            return h('div', { key: 't' + tableIndex },
+              h('div', { className: 'rw-doc-block-label' }, t('docTable') + ' ' + (tableIndex + 1)),
+              h('table', { className: 'rw-doc-table' }, h('tbody', null,
+                rows.map(function (row, rowIndex) {
+                  return h('tr', { key: rowIndex }, row.map(function (cell, cellIndex) {
+                    return h('td', { key: cellIndex }, h('input', { value: cell || '', onChange: function (event) { updateTableCell(tableIndex, rowIndex, cellIndex, event.currentTarget.value); } }));
+                  }));
+                }))));
+          }));
+      } else if (kind === 'xlsx' && state.data) {
+        var sheets = state.data.sheets || [];
+        var active = sheets[Math.min(state.sheet, Math.max(sheets.length - 1, 0))] || { name: '', rows: [] };
+        var columns = Math.max(active.maxCol || 0, 8);
+        var header = h('tr', null, h('th', null, ''), Array.from({ length: columns }, function (_, index) { return h('th', { key: index }, String.fromCharCode(65 + index)); }));
+        var gridRows = (active.rows || []).map(function (row, rowIndex) {
+          return h('tr', { key: rowIndex },
+            h('th', null, String(rowIndex + 1)),
+            Array.from({ length: columns }, function (_, colIndex) {
+              var cell = String.fromCharCode(65 + colIndex) + (rowIndex + 1);
+              var value = row[colIndex];
+              return h('td', { key: colIndex }, h('input', {
+                value: value === null || value === undefined ? '' : String(value),
+                onChange: function (event) { updateCell(active.name, cell, event.currentTarget.value); },
+              }));
+            }));
+        });
+        body = h('div', { className: 'rw-doc-body', style: { padding: 0, overflow: 'hidden' } },
+          h('div', { className: 'rw-doc-tabs' }, sheets.map(function (sheet, index) {
+            return h('button', { key: sheet.name, type: 'button', className: 'rw-doc-tab' + (index === state.sheet ? ' is-on' : ''), onClick: function () { patch({ sheet: index }); } }, sheet.name);
+          })),
+          h('div', { style: { flex: '1 1 auto', overflow: 'auto', padding: 8 } },
+            h('table', { className: 'rw-doc-grid' },
+              h('thead', null, header),
+              h('tbody', null, gridRows))));
+      } else if (kind === 'pptx' && state.data) {
+        var slides = state.data.slides || [];
+        var slide = slides[Math.min(state.slide, Math.max(slides.length - 1, 0))] || { texts: [] };
+        body = h('div', { className: 'rw-doc-body' },
+          h('div', { className: 'rw-inline', style: { justifyContent: 'space-between', marginBottom: 6 } },
+            h('div', { className: 'rw-inline' },
+              h('button', { type: 'button', className: 'rw-btn rw-btn-sm', disabled: state.slide <= 0, onClick: function () { patch({ slide: state.slide - 1 }); } }, '‹'),
+              h('span', { className: 'rw-hint' }, (state.slide + 1) + ' / ' + slides.length),
+              h('button', { type: 'button', className: 'rw-btn rw-btn-sm', disabled: state.slide >= slides.length - 1, onClick: function () { patch({ slide: state.slide + 1 }); } }, '›'))),
+          (slide.texts || []).map(function (item) {
+            return h('div', { key: item.shape, className: 'rw-doc-block' },
+              h('div', { className: 'rw-doc-block-label' }, (item.name || t('docSlide')) + ' · ' + item.shape),
+              h('textarea', { value: (state.pptxUpdates[state.slide + ':' + item.shape] || item).text || '', onChange: function (event) { updateSlideText(state.slide, item.shape, event.currentTarget.value); } }));
+          }));
+      }
+
+      return h('div', { className: 'rw-doc' }, toolbar,
+        state.notice ? h('div', { style: { padding: '6px 10px 0' } }, h(Banner, { kind: 'success' }, state.notice)) : null,
+        state.error ? h('div', { style: { padding: '6px 10px 0' } }, h(Banner, { kind: 'error' }, state.error)) : null,
+        body,
+        h('div', { className: 'rw-doc-status' },
+          h('span', null, kind.toUpperCase()),
+          h('span', null, path),
+          state.dirty ? h('span', { className: 'rw-status-chip rw-status-warn' }, t('dirty')) : null));
+    }
+
     function RemoteDirectoryTab(props) {
       var ctx = props.ctx;
       var t = props.t;
@@ -4734,19 +5059,25 @@ function fileIconSpec(name, isDir) {
 
       function submitNew(side, dirPath, name, isDir) {
         var target = joinChildPath(dirPath, name, side);
+        var docKind = documentKindOf(name);
         var promise;
-        if (side === 'remote') {
-          promise = isDir
+        if (isDir) {
+          promise = side === 'remote'
             ? apiCall('fs.mkdir', Object.assign({ path: target }, scopeParams(scopeRef)))
-            : apiCall('fs.write', Object.assign({ path: target, content: '' }, scopeParams(scopeRef)));
+            : apiCall('local.mkdir', { path: dirPath, name: name });
+        } else if (docKind) {
+          promise = side === 'remote'
+            ? apiCall('docs.create', Object.assign({ path: target, kind: docKind }, scopeParams(scopeRef)))
+            : apiCall('docs.create', { path: target, kind: docKind });
         } else {
-          promise = isDir
-            ? apiCall('local.mkdir', { path: dirPath, name: name })
+          promise = side === 'remote'
+            ? apiCall('fs.write', Object.assign({ path: target, content: '' }, scopeParams(scopeRef)))
             : apiCall('local.newFile', { path: target });
         }
         promise.then(function () {
           showNotice('success', t('newDone'));
           refreshTree();
+          if (!isDir && docKind) openInternalFile(side, target);
         }).catch(noticeError);
       }
 
@@ -4997,8 +5328,25 @@ function fileIconSpec(name, isDir) {
       }
 
       var activeFile = openFiles.filter(function (file) { return file.key === activeFileKey; })[0] || null;
+      var activeDocKind = activeFile ? documentKindOf(activeFile.name) : '';
       var contentArea = activeFile
-        ? h(RemoteFileEditor, {
+        ? (activeDocKind
+          ? h(DocumentPane, {
+            ctx: ctx, t: t, locale: locale,
+            scope: activeFile.side === 'remote' ? sourceScopeOf(selected) : undefined,
+            path: activeFile.path,
+            local: activeFile.side === 'local',
+            onSaved: refreshTree,
+            onDirtyChange: function (dirty) {
+              setFileDirty(function (previous) {
+                if (Boolean(previous[activeFile.key]) === Boolean(dirty)) return previous;
+                var next = Object.assign({}, previous);
+                next[activeFile.key] = Boolean(dirty);
+                return next;
+              });
+            },
+          })
+          : h(RemoteFileEditor, {
           ctx: ctx, t: t, locale: locale,
           scope: activeFile.side === 'remote' ? sourceScopeOf(selected) : undefined,
           path: activeFile.path,
@@ -5013,7 +5361,7 @@ function fileIconSpec(name, isDir) {
               return next;
             });
           },
-        })
+        }))
         : h('div', { className: 'rw-placeholder' },
           h('span', { style: { display: 'inline-flex', opacity: 0.7 } }, IconFolder(30, false)),
           h('div', { className: 'rw-placeholder-title' }, t('openFileTitle')),

package/lib/index.js

@@ -16,11 +16,12 @@
  * addresses and workspace paths.
  */
 import { randomUUID } from 'node:crypto'
-import { chmodSync, cpSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from 'node:fs'
+import { chmodSync, cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from 'node:fs'
 import { spawn } from 'node:child_process'
 import { mkdir, readdir, stat as fsStat } from 'node:fs/promises'
 import { homedir, tmpdir } from 'node:os'
-import { basename, dirname, isAbsolute, join, posix, resolve, sep } from 'node:path'
+import { basename, dirname, extname, isAbsolute, join, posix, resolve, sep } from 'node:path'
+import { fileURLToPath } from 'node:url'
 import { listHosts, RemoteHost, SshError } from './ssh.js'
 import * as linkedFs from './linked.js'
 import * as git from './git.js'
@@ -1423,6 +1424,129 @@ export function apply(ctx) {
     }
   }
 
+  // ── document bridge (Markdown/PDF/DOCX/XLSX/PPTX) ──────────────────────
+
+  const DOC_MAX_BYTES = 80 * 1024 * 1024
+  const DOC_TOOL = join(dirname(fileURLToPath(import.meta.url)), '..', 'scripts', 'doc_tool.py')
+  const DOC_KIND_BY_EXT = new Map([
+    ['.md', 'markdown'], ['.markdown', 'markdown'],
+    ['.pdf', 'pdf'], ['.docx', 'docx'], ['.xlsx', 'xlsx'], ['.pptx', 'pptx'],
+  ])
+
+  function docKind(path) {
+    return DOC_KIND_BY_EXT.get(extname(String(path || '')).toLowerCase()) || ''
+  }
+
+  function docPython() {
+    return process.env.DSH_OFFICE_PYTHON || process.env.DSH_PYTHON || (process.platform === 'win32' ? 'python' : 'python3')
+  }
+
+  function runDocTool(args, timeoutMs = 120000) {
+    return new Promise((resolvePromise, rejectPromise) => {
+      let child
+      try {
+        child = spawn(docPython(), [DOC_TOOL, ...args], { windowsHide: true })
+      } catch (error) {
+        rejectPromise(new ApiError('DOC_RUNTIME', '需要 Python 3 与文档库：' + (error && error.message ? error.message : error)))
+        return
+      }
+      const out = []
+      const err = []
+      const timer = setTimeout(() => {
+        try { child.kill() } catch { /* already gone */ }
+        rejectPromise(new ApiError('DOC_TIMEOUT', '文档处理超时'))
+      }, timeoutMs)
+      child.stdout.on('data', (chunk) => out.push(chunk))
+      child.stderr.on('data', (chunk) => err.push(chunk))
+      child.on('error', (error) => {
+        clearTimeout(timer)
+        if (error && error.code === 'ENOENT') {
+          rejectPromise(new ApiError('DOC_RUNTIME', '未找到 Python。请安装 Python 3 以及 python-docx / openpyxl / python-pptx / PyMuPDF，或设置 DSH_OFFICE_PYTHON。'))
+        } else {
+          rejectPromise(new ApiError('DOC_RUNTIME', error && error.message ? error.message : String(error)))
+        }
+      })
+      child.on('close', (code) => {
+        clearTimeout(timer)
+        const stdout = Buffer.concat(out).toString('utf8')
+        const stderr = Buffer.concat(err).toString('utf8')
+        let parsed
+        try {
+          parsed = JSON.parse(stdout.trim().split(String.fromCharCode(10)).filter(Boolean).pop() || '{}')
+        } catch {
+          parsed = null
+        }
+        if (code !== 0 || !parsed || parsed.ok !== true) {
+          const message = (parsed && parsed.error) || stderr.trim() || ('文档处理失败（退出码 ' + code + '）')
+          rejectPromise(new ApiError('DOC_FAILED', String(message).slice(0, 800)))
+          return
+        }
+        resolvePromise(parsed.data)
+      })
+    })
+  }
+
+  async function docTarget(params) {
+    if (params.linkedId || params.workspaceId) {
+      const scope = await requireScope(params)
+      const target = scopeTarget(scope, params.path)
+      return { remote: true, scope, path: target }
+    }
+    const raw = typeof params.path === 'string' ? params.path.trim() : ''
+    if (raw === '' || !isAbsolute(raw)) throw new ApiError('BAD_REQUEST', '本地路径必须是绝对路径')
+    return { remote: false, path: resolve(raw) }
+  }
+
+  async function readDocBytes(target, current) {
+    if (!current.remote) {
+      const info = await fsStat(current.path)
+      if (!info.isFile()) throw new ApiError('FS_NOT_DIR', '只能打开文件')
+      if (info.size > DOC_MAX_BYTES) throw new ApiError('DOC_TOO_LARGE', '文档超过 80 MB')
+      return { data: readFileSync(current.path), mtime: info.mtimeMs, size: info.size }
+    }
+    const stat = await current.scope.remote.stat(current.path)
+    if (stat.type !== 'file') throw new ApiError('FS_NOT_DIR', '只能打开文件')
+    if (stat.size > DOC_MAX_BYTES) throw new ApiError('DOC_TOO_LARGE', '文档超过 80 MB')
+    const read = await current.scope.remote.readFile(current.path, { maxBytes: DOC_MAX_BYTES })
+    return { data: read.data, mtime: stat.mtime, size: stat.size }
+  }
+
+  async function writeDocBytes(target, data) {
+    if (!target.remote) {
+      await mkdir(dirname(target.path), { recursive: true })
+      const temp = target.path + '.' + randomUUID() + '.tmp'
+      writeFileSync(temp, data)
+      try { renameSync(temp, target.path) } catch (error) { rmSync(temp, { force: true }); throw error }
+      const info = await fsStat(target.path)
+      return { path: target.path, size: info.size, mtime: info.mtimeMs }
+    }
+    const result = await target.scope.remote.writeFileAtomic(target.path, data)
+    return { path: target.path, size: result.size, mtime: result.mtime }
+  }
+
+  async function makeDocTemp() {
+    const directory = mkdtempSync(join(tmpdir(), 'dsh-doc-'))
+    return {
+      dir: directory,
+      file(name) { return join(directory, name) },
+      cleanup() { try { rmSync(directory, { recursive: true, force: true }) } catch { /* best effort */ } },
+    }
+  }
+
+  function assertDocKind(path, expected) {
+    const kind = docKind(path)
+    if (kind === '') throw new ApiError('DOC_UNSUPPORTED', '仅支持 Markdown、PDF、DOCX、XLSX、PPTX')
+    if (expected && expected !== kind) throw new ApiError('DOC_UNSUPPORTED', '文件类型与请求不一致')
+    return kind
+  }
+
+  async function docStat(target) {
+    if (!target.remote) {
+      try { const info = await fsStat(target.path); return info } catch { return null }
+    }
+    try { return await target.scope.remote.stat(target.path) } catch { return null }
+  }
+
   // ── method table ─────────────────────────────────────────────────────────
 
   const methods = {
@@ -1606,6 +1730,136 @@ export function apply(ctx) {
       return { path: target, size: info.size, mtime: info.mtime }
     },
 
+    async 'docs.read'(params = {}) {
+      const target = await docTarget(params)
+      const kind = assertDocKind(target.path)
+      const current = await readDocBytes(target, target)
+      if (kind === 'markdown') {
+        if (looksBinary(current.data)) throw new ApiError('DOC_BINARY', 'Markdown 文件包含二进制内容')
+        return { kind, path: target.path, text: decodeUtf8(current.data), size: current.size, mtime: current.mtime }
+      }
+      const temp = await makeDocTemp()
+      try {
+        const input = temp.file('input.' + (kind === 'markdown' ? 'md' : kind))
+        writeFileSync(input, current.data)
+        const data = await runDocTool(['read', '--kind', kind, '--file', input])
+        return { ...data, path: target.path, size: current.size, mtime: current.mtime }
+      } finally {
+        temp.cleanup()
+      }
+    },
+
+    async 'docs.write'(params = {}) {
+      const target = await docTarget(params)
+      const kind = assertDocKind(target.path)
+      const data = params.data
+      if (!data || typeof data !== 'object') throw new ApiError('BAD_REQUEST', '缺少文档数据')
+      if (typeof params.expectedMtime === 'number' && params.expectedMtime > 0) {
+        const current = await docStat(target)
+        if (current && Math.floor(current.mtime / 1000) !== Math.floor(params.expectedMtime / 1000)) {
+          throw new ApiError('CONFLICT', '文件已被修改，请重新加载后再保存')
+        }
+      }
+      if (kind === 'markdown') {
+        if (typeof data.text !== 'string') throw new ApiError('BAD_REQUEST', 'Markdown 内容无效')
+        const written = await writeDocBytes(target, Buffer.from(data.text, 'utf8'))
+        return { kind, ...written }
+      }
+      const current = await readDocBytes(target, target)
+      const temp = await makeDocTemp()
+      try {
+        const source = temp.file('source.' + kind)
+        const spec = temp.file('data.json')
+        const output = temp.file('output.' + kind)
+        writeFileSync(source, current.data)
+        writeFileSync(spec, JSON.stringify(data))
+        await runDocTool(['write', '--kind', kind, '--file', source, '--data', spec, '--out', output])
+        const written = await writeDocBytes(target, readFileSync(output))
+        return { kind, ...written }
+      } finally {
+        temp.cleanup()
+      }
+    },
+
+    async 'docs.create'(params = {}) {
+      const target = await docTarget(params)
+      const kind = assertDocKind(target.path, params.kind)
+      const existing = await docStat(target)
+      if (existing) throw new ApiError('FS_EXISTS', '目标文件已存在')
+      const temp = await makeDocTemp()
+      try {
+        const cliKind = kind === 'markdown' ? 'md' : kind
+        const output = temp.file('new.' + cliKind)
+        await runDocTool(['create', '--kind', cliKind, '--out', output])
+        const written = await writeDocBytes(target, readFileSync(output))
+        return { kind, ...written }
+      } finally {
+        temp.cleanup()
+      }
+    },
+
+    async 'docs.mdPreview'(params = {}) {
+      const target = await docTarget(params)
+      assertDocKind(target.path, 'markdown')
+      let text = typeof params.text === 'string' ? params.text : null
+      if (text === null) {
+        const current = await readDocBytes(target, target)
+        text = decodeUtf8(current.data)
+      }
+      const temp = await makeDocTemp()
+      try {
+        const input = temp.file('preview.md')
+        writeFileSync(input, text, 'utf8')
+        const data = await runDocTool(['md-preview', '--file', input])
+        return data
+      } finally {
+        temp.cleanup()
+      }
+    },
+
+    async 'docs.mdPdf'(params = {}) {
+      const target = await docTarget(params)
+      assertDocKind(target.path, 'markdown')
+      let text = typeof params.text === 'string' ? params.text : null
+      if (text === null) {
+        const current = await readDocBytes(target, target)
+        text = decodeUtf8(current.data)
+      }
+      const extension = extname(target.path)
+      const base = target.path.slice(0, -extension.length)
+      let outputPath = base + '.pdf'
+      if (target.remote) {
+        const directory = posix.dirname(outputPath)
+        let candidate = outputPath
+        let index = 1
+        while (await target.scope.remote.stat(candidate).catch(() => null)) {
+          candidate = posix.join(directory, posix.basename(base) + '-' + index + '.pdf')
+          index += 1
+        }
+        outputPath = candidate
+      } else {
+        const directory = dirname(outputPath)
+        let candidate = outputPath
+        let index = 1
+        while (existsSync(candidate)) {
+          candidate = join(directory, basename(base) + '-' + index + '.pdf')
+          index += 1
+        }
+        outputPath = candidate
+      }
+      const temp = await makeDocTemp()
+      try {
+        const input = temp.file('export.md')
+        const output = temp.file('export.pdf')
+        writeFileSync(input, text, 'utf8')
+        await runDocTool(['md-pdf', '--file', input, '--out', output], 180000)
+        const written = await writeDocBytes({ ...target, path: outputPath }, readFileSync(output))
+        return { kind: 'pdf', ...written }
+      } finally {
+        temp.cleanup()
+      }
+    },
+
     async 'fs.stat'(params = {}) {
       const scope = await requireScope(params)
       const target = scopeTarget(scope, params.path)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-linked-workspace",
-  "version": "0.5.13",
+  "version": "0.6.0",
   "description": "Linked local ⇄ remote workspaces and SSH-backed remote directories for DeepSeek Harness: theme-aware split editor, file-type icons, and an agent tool that edits remote files directly.",
   "type": "module",
   "main": "lib/index.js",
@@ -22,7 +22,8 @@
     "LICENSE",
     "README.en.md",
     "docs/API.md",
-    "docs/VERIFY.md"
+    "docs/VERIFY.md",
+    "scripts/doc_tool.py"
   ],
   "keywords": [
     "deepseek-harness",

package/scripts/doc_tool.py

@@ -0,0 +1,405 @@
+#!/usr/bin/env python3
+"""Document bridge for dsh-linked-workspace.
+
+Reads/edits Markdown, PDF, DOCX, XLSX and PPTX files.  It is intentionally a
+small, dependency-light helper: python-docx / openpyxl / python-pptx / PyMuPDF
+are only needed when the corresponding format is used.
+"""
+import argparse
+import base64
+import datetime
+import json
+import os
+import re
+import sys
+
+MAX_PDF_PAGES = 40
+MAX_PDF_WIDTH = 1100
+MAX_SHEET_ROWS = 200
+MAX_SHEET_COLS = 40
+MAX_PPTX_SLIDES = 80
+
+
+def fail(message):
+    print(json.dumps({"ok": False, "error": str(message)}, ensure_ascii=False))
+    sys.exit(1)
+
+
+def emit(data):
+    print(json.dumps({"ok": True, "data": data}, ensure_ascii=False))
+
+
+def json_value(value):
+    if value is None:
+        return None
+    if isinstance(value, (datetime.datetime, datetime.date, datetime.time)):
+        return value.isoformat()
+    if isinstance(value, (int, float, bool, str)):
+        return value
+    return str(value)
+
+
+# ── DOCX ──────────────────────────────────────────────────────────────────
+
+def read_docx(path):
+    from docx import Document
+    from docx.table import Table
+    from docx.text.paragraph import Paragraph
+
+    doc = Document(path)
+    paragraphs = []
+    for paragraph in doc.paragraphs:
+        paragraphs.append({
+            "style": paragraph.style.name if paragraph.style is not None else "",
+            "text": paragraph.text,
+        })
+    tables = []
+    for table in doc.tables:
+        rows = []
+        for row in table.rows:
+            rows.append([cell.text for cell in row.cells])
+        tables.append(rows)
+    emit({"kind": "docx", "paragraphs": paragraphs, "tables": tables})
+
+
+def write_docx(source, data, out):
+    from docx import Document
+
+    doc = Document(source)
+    paragraphs = data.get("paragraphs")
+    if isinstance(paragraphs, list):
+        for index, block in enumerate(paragraphs):
+            if index >= len(doc.paragraphs):
+                break
+            if isinstance(block, dict) and isinstance(block.get("text"), str):
+                doc.paragraphs[index].text = block["text"]
+    tables = data.get("tables")
+    if isinstance(tables, list):
+        for table_index, rows in enumerate(tables):
+            if table_index >= len(doc.tables) or not isinstance(rows, list):
+                continue
+            table = doc.tables[table_index]
+            for row_index, row in enumerate(rows):
+                if row_index >= len(table.rows) or not isinstance(row, list):
+                    continue
+                for cell_index, value in enumerate(row):
+                    if cell_index >= len(table.rows[row_index].cells):
+                        continue
+                    if isinstance(value, str):
+                        table.rows[row_index].cells[cell_index].text = value
+    doc.save(out)
+    emit({"kind": "docx", "path": out})
+
+
+# ── XLSX ──────────────────────────────────────────────────────────────────
+
+def read_xlsx(path):
+    from openpyxl import load_workbook
+
+    workbook = load_workbook(path, data_only=False)
+    sheets = []
+    for sheet in workbook.worksheets[:20]:
+        rows = []
+        max_row = min(sheet.max_row or 0, MAX_SHEET_ROWS)
+        max_col = min(sheet.max_column or 0, MAX_SHEET_COLS)
+        for row in sheet.iter_rows(min_row=1, max_row=max_row, min_col=1, max_col=max_col):
+            rows.append([json_value(cell.value) for cell in row])
+        sheets.append({
+            "name": sheet.title,
+            "rows": rows,
+            "maxRow": max_row,
+            "maxCol": max_col,
+            "frozen": bool(sheet.freeze_panes),
+        })
+    emit({"kind": "xlsx", "sheets": sheets, "sheetCount": len(workbook.worksheets)})
+
+
+def write_xlsx(source, data, out):
+    from openpyxl import load_workbook
+
+    workbook = load_workbook(source)
+    updates = data.get("updates") or []
+    for update in updates:
+        if not isinstance(update, dict):
+            continue
+        sheet_name = update.get("sheet")
+        cell = update.get("cell")
+        value = update.get("value")
+        if not isinstance(sheet_name, str) or not isinstance(cell, str):
+            continue
+        if sheet_name not in workbook.sheetnames:
+            continue
+        if not re.match(r"^[A-Za-z]{1,3}[1-9][0-9]*$", cell):
+            continue
+        if isinstance(value, str) and value.startswith("="):
+            workbook[sheet_name][cell] = value
+        elif isinstance(value, str) and re.match(r"^-?(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)$", value.strip()):
+            number = value.strip()
+            workbook[sheet_name][cell] = float(number) if "." in number else int(number)
+        elif value == "":
+            workbook[sheet_name][cell] = None
+        else:
+            workbook[sheet_name][cell] = value
+    workbook.save(out)
+    emit({"kind": "xlsx", "path": out})
+
+
+# ── PPTX ──────────────────────────────────────────────────────────────────
+
+def read_pptx(path):
+    from pptx import Presentation
+
+    presentation = Presentation(path)
+    slides = []
+    for slide_index, slide in enumerate(presentation.slides):
+        if slide_index >= MAX_PPTX_SLIDES:
+            break
+        texts = []
+        for shape_index, shape in enumerate(slide.shapes):
+            if not getattr(shape, "has_text_frame", False):
+                continue
+            text = shape.text_frame.text
+            if text.strip() == "":
+                continue
+            texts.append({
+                "shape": shape_index,
+                "name": getattr(shape, "name", ""),
+                "text": text,
+            })
+        slides.append({"index": slide_index, "texts": texts})
+    emit({"kind": "pptx", "slides": slides, "slideCount": len(presentation.slides)})
+
+
+def write_pptx(source, data, out):
+    from pptx import Presentation
+
+    presentation = Presentation(source)
+    updates = data.get("updates") or []
+    for update in updates:
+        if not isinstance(update, dict):
+            continue
+        slide_index = update.get("slide")
+        shape_index = update.get("shape")
+        text = update.get("text")
+        if not isinstance(slide_index, int) or not isinstance(shape_index, int) or not isinstance(text, str):
+            continue
+        if slide_index < 0 or slide_index >= len(presentation.slides):
+            continue
+        slide = presentation.slides[slide_index]
+        if shape_index < 0 or shape_index >= len(slide.shapes):
+            continue
+        shape = slide.shapes[shape_index]
+        if not getattr(shape, "has_text_frame", False):
+            continue
+        shape.text_frame.text = text
+    presentation.save(out)
+    emit({"kind": "pptx", "path": out})
+
+
+# ── PDF ───────────────────────────────────────────────────────────────────
+
+def read_pdf(path):
+    import fitz
+
+    doc = fitz.open(path)
+    pages = []
+    for index, page in enumerate(doc):
+        if index >= MAX_PDF_PAGES:
+            break
+        rect = page.rect
+        scale = min(1.5, MAX_PDF_WIDTH / max(rect.width, 1))
+        pixmap = page.get_pixmap(matrix=fitz.Matrix(scale, scale), alpha=False)
+        pages.append({
+            "index": index,
+            "width": rect.width,
+            "height": rect.height,
+            "rotation": page.rotation,
+            "png": "data:image/png;base64," + base64.b64encode(pixmap.tobytes("png")).decode("ascii"),
+        })
+    metadata = doc.metadata or {}
+    emit({
+        "kind": "pdf",
+        "pageCount": doc.page_count,
+        "metadata": {
+            "title": metadata.get("title", ""),
+            "author": metadata.get("author", ""),
+            "subject": metadata.get("subject", ""),
+        },
+        "pages": pages,
+        "truncated": doc.page_count > MAX_PDF_PAGES,
+    })
+
+
+def write_pdf(source, data, out):
+    import fitz
+
+    doc = fitz.open(source)
+    metadata = data.get("metadata") or {}
+    if isinstance(metadata, dict):
+        current = doc.metadata or {}
+        current.update({
+            "title": metadata.get("title", current.get("title", "")),
+            "author": metadata.get("author", current.get("author", "")),
+            "subject": metadata.get("subject", current.get("subject", "")),
+        })
+        doc.set_metadata(current)
+    for item in data.get("rotations") or []:
+        if not isinstance(item, dict):
+            continue
+        index = item.get("index")
+        degrees = item.get("degrees")
+        if isinstance(index, int) and 0 <= index < doc.page_count and isinstance(degrees, int):
+            page = doc[index]
+            page.set_rotation(degrees % 360)
+    deleted = [item for item in (data.get("deleted") or []) if isinstance(item, int)]
+    for index in sorted(set(deleted), reverse=True):
+        if 0 <= index < doc.page_count and doc.page_count > 1:
+            doc.delete_page(index)
+    doc.save(out, garbage=3, deflate=True)
+    doc.close()
+    emit({"kind": "pdf", "path": out})
+
+
+# ── create / Markdown ─────────────────────────────────────────────────────
+
+def create(kind, out):
+    if kind == "md":
+        with open(out, "w", encoding="utf-8") as handle:
+            handle.write("")
+    elif kind == "docx":
+        from docx import Document
+
+        document = Document()
+        document.add_paragraph("")
+        document.save(out)
+    elif kind == "xlsx":
+        from openpyxl import Workbook
+
+        workbook = Workbook()
+        workbook.active.title = "Sheet1"
+        workbook.save(out)
+    elif kind == "pptx":
+        from pptx import Presentation
+
+        presentation = Presentation()
+        layout = presentation.slide_layouts[1] if len(presentation.slide_layouts) > 1 else presentation.slide_layouts[0]
+        slide = presentation.slides.add_slide(layout)
+        slide.shapes.title.text = "New presentation"
+        presentation.save(out)
+    elif kind == "pdf":
+        import fitz
+
+        document = fitz.open()
+        document.new_page()
+        document.save(out)
+        document.close()
+    else:
+        raise ValueError(f"unsupported kind: {kind}")
+    emit({"kind": kind, "path": out})
+
+
+def markdown_to_html(path):
+    import markdown
+
+    with open(path, "r", encoding="utf-8", errors="replace") as handle:
+        text = handle.read()
+    body = markdown.markdown(text, extensions=["extra", "sane_lists", "tables", "fenced_code"])
+    html = """<!doctype html><html><head><meta charset="utf-8"><style>
+body{font-family:system-ui,-apple-system,"Segoe UI",sans-serif;line-height:1.65;color:#1f2328;max-width:900px;margin:0 auto;padding:28px;font-size:15px}
+h1,h2,h3,h4{line-height:1.3;margin:1.2em 0 .55em} h1{font-size:1.8em;border-bottom:1px solid #e5e7eb;padding-bottom:.25em}
+pre{background:#f6f8fa;padding:12px;border-radius:8px;overflow:auto} code{font-family:ui-monospace,Consolas,monospace;font-size:.92em}
+pre code{background:none;padding:0} blockquote{border-left:4px solid #d0d7de;margin:0;padding:0 1em;color:#57606a}
+table{border-collapse:collapse;margin:1em 0} th,td{border:1px solid #d0d7de;padding:6px 10px;text-align:left}
+img{max-width:100%} a{color:#0969da} hr{border:0;border-top:1px solid #d0d7de;margin:1.5em 0}
+</style></head><body>""" + body + "</body></html>"
+    return html
+
+
+def markdown_preview(path):
+    html = markdown_to_html(path)
+    emit({"kind": "markdown-preview", "html": html})
+
+
+def markdown_pdf(path, out):
+    import fitz
+
+    html = markdown_to_html(path)
+    story = fitz.Story(html=html)
+    writer = fitz.DocumentWriter(out)
+    mediabox = fitz.paper_rect("a4")
+    page_rect = mediabox + (48, 48, -48, -48)
+    more = True
+    while more:
+        device = writer.begin_page(mediabox)
+        more, _ = story.place(page_rect)
+        story.draw(device)
+        writer.end_page()
+    writer.close()
+    emit({"kind": "pdf", "path": out})
+
+
+# ── CLI ───────────────────────────────────────────────────────────────────
+
+def main():
+    parser = argparse.ArgumentParser(description="dsh-linked-workspace document bridge")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    read = sub.add_parser("read")
+    read.add_argument("--kind", required=True)
+    read.add_argument("--file", required=True)
+
+    write = sub.add_parser("write")
+    write.add_argument("--kind", required=True)
+    write.add_argument("--file", required=True)
+    write.add_argument("--data", required=True)
+    write.add_argument("--out", required=True)
+
+    create_parser = sub.add_parser("create")
+    create_parser.add_argument("--kind", required=True)
+    create_parser.add_argument("--out", required=True)
+
+    preview = sub.add_parser("md-preview")
+    preview.add_argument("--file", required=True)
+
+    pdf = sub.add_parser("md-pdf")
+    pdf.add_argument("--file", required=True)
+    pdf.add_argument("--out", required=True)
+
+    args = parser.parse_args()
+    try:
+        if args.command == "read":
+            if args.kind == "docx":
+                read_docx(args.file)
+            elif args.kind == "xlsx":
+                read_xlsx(args.file)
+            elif args.kind == "pptx":
+                read_pptx(args.file)
+            elif args.kind == "pdf":
+                read_pdf(args.file)
+            else:
+                raise ValueError(f"unsupported kind: {args.kind}")
+        elif args.command == "write":
+            with open(args.data, "r", encoding="utf-8") as handle:
+                data = json.load(handle)
+            if args.kind == "docx":
+                write_docx(args.file, data, args.out)
+            elif args.kind == "xlsx":
+                write_xlsx(args.file, data, args.out)
+            elif args.kind == "pptx":
+                write_pptx(args.file, data, args.out)
+            elif args.kind == "pdf":
+                write_pdf(args.file, data, args.out)
+            else:
+                raise ValueError(f"unsupported kind: {args.kind}")
+        elif args.command == "create":
+            create(args.kind, args.out)
+        elif args.command == "md-preview":
+            markdown_preview(args.file)
+        elif args.command == "md-pdf":
+            markdown_pdf(args.file, args.out)
+    except Exception as error:  # pragma: no cover - CLI boundary
+        fail(error)
+
+
+if __name__ == "__main__":
+    main()