dsh-winrm 0.3.1 → 0.4.1

package/scripts/verify-live.mts

@@ -6,6 +6,7 @@
 // Run from the repo root so `winrm-client` resolves:
 //   node --experimental-strip-types scripts/verify-live.mts
 import { HostStore } from '../src/store.ts'
+import { WinRmEngine } from '../src/engine.ts'
 import { connOf, runScript, TRANSFER_CHUNK, uploadBuffer, downloadChunks, remoteFileSize } from '../src/engine/client.ts'
 import { psWriteChunk, psReadChunk, psFileSize } from '../src/powershell.ts'
 
@@ -106,6 +107,121 @@ console.log('=== upload/download round trip ===')
   await runScript(conn, `Remove-Item -LiteralPath 'C:\\temp\\dsh-winrm-verify' -Recurse -Force -ErrorAction SilentlyContinue`, { timeoutMs: 60_000 })
 }
 
+// Remote text read/write/edit: the three tools that act on the target's files
+// rather than on the host's. Round-trips through the real encoding detection.
+console.log('=== remote text read/write/edit ===')
+{
+  const engine = new WinRmEngine(store)
+  const dir = 'C:\\temp\\dsh-winrm-verify-text'
+  const alias = entry.alias
+  const body = ['alpha', '中文行 ✓', '', 'beta alpha', 'omega'].join('\r\n') + '\r\n'
+
+  const created = await engine.writeFile(alias, `${dir}\\utf8.txt`, body, 'utf8')
+  const createOk = created.operation === 'create' && created.bytes === Buffer.byteLength(body, 'utf8')
+  if (!createOk) bad++
+  console.log(`${createOk ? 'ok  ' : 'BAD '} write create utf8: op=${created.operation} bytes=${created.bytes}`)
+
+  const updated = await engine.writeFile(alias, `${dir}\\utf8.txt`, body, 'utf8')
+  const updateOk = updated.operation === 'update'
+  if (!updateOk) bad++
+  console.log(`${updateOk ? 'ok  ' : 'BAD '} write update utf8: op=${updated.operation}`)
+
+  const window = await engine.readFile(alias, `${dir}\\utf8.txt`, 1, 100)
+  const readOk = window.totalLines === 5
+    && window.encoding === 'utf8'
+    && window.lines[0]?.text === 'alpha'
+    && window.lines[1]?.text === '中文行 ✓'
+    && window.lines[2]?.text === ''
+    && window.lines[4]?.text === 'omega'
+  if (!readOk) bad++
+  console.log(`${readOk ? 'ok  ' : 'BAD '} read whole: total=${window.totalLines} enc=${window.encoding} lines=${JSON.stringify(window.lines.map(l => l.text))}`)
+
+  // Paging must start where the caller asked, or a model paging a log would
+  // silently re-read the top forever.
+  const tail = await engine.readFile(alias, `${dir}\\utf8.txt`, 4, 2)
+  const pageOk = tail.lines.length === 2 && tail.lines[0]?.number === 4 && tail.lines[0]?.text === 'beta alpha'
+  if (!pageOk) bad++
+  console.log(`${pageOk ? 'ok  ' : 'BAD '} read page offset=4 limit=2: ${JSON.stringify(tail.lines)}`)
+
+  const edited = await engine.editFile(alias, `${dir}\\utf8.txt`, 'omega', 'OMEGA', false)
+  const editOk = edited.replacements === 1 && edited.encoding === 'utf8'
+  if (!editOk) bad++
+  console.log(`${editOk ? 'ok  ' : 'BAD '} edit single: replacements=${edited.replacements} size=${edited.size}`)
+
+  const afterEdit = await engine.readFile(alias, `${dir}\\utf8.txt`, 1, 100)
+  const persisted = afterEdit.lines[4]?.text === 'OMEGA'
+  if (!persisted) bad++
+  console.log(`${persisted ? 'ok  ' : 'BAD '} edit persisted: line5=${JSON.stringify(afterEdit.lines[4]?.text)}`)
+
+  // `alpha` appears twice, so a single-replacement edit must refuse rather than
+  // guess which one the caller meant.
+  let ambiguous = ''
+  try {
+    await engine.editFile(alias, `${dir}\\utf8.txt`, 'alpha', 'ALPHA', false)
+  } catch (error) {
+    ambiguous = error instanceof Error ? error.message : String(error)
+  }
+  const ambiguousOk = ambiguous.includes('more than once')
+  if (!ambiguousOk) bad++
+  console.log(`${ambiguousOk ? 'ok  ' : 'BAD '} edit refuses ambiguous needle: ${JSON.stringify(ambiguous)}`)
+
+  const all = await engine.editFile(alias, `${dir}\\utf8.txt`, 'alpha', 'ALPHA', true)
+  const allOk = all.replacements === 2
+  if (!allOk) bad++
+  console.log(`${allOk ? 'ok  ' : 'BAD '} edit replaceAll: replacements=${all.replacements}`)
+
+  // A needle that is gone must fail loudly: silently succeeding is how a stale
+  // edit looks successful while changing nothing.
+  let missing = ''
+  try {
+    await engine.editFile(alias, `${dir}\\utf8.txt`, 'not-there-at-all', 'x', false)
+  } catch (error) {
+    missing = error instanceof Error ? error.message : String(error)
+  }
+  const missingOk = missing.includes('was not found')
+  if (!missingOk) bad++
+  console.log(`${missingOk ? 'ok  ' : 'BAD '} edit reports a missing needle: ${JSON.stringify(missing)}`)
+
+  // UTF-16LE with a BOM must come back as UTF-16LE, not as mojibake.
+  const utf16 = await engine.writeFile(alias, `${dir}\\utf16.txt`, '第一行\r\n第二行\r\n', 'utf16le')
+  const utf16Read = await engine.readFile(alias, `${dir}\\utf16.txt`, 1, 10)
+  const utf16Ok = utf16Read.encoding === 'utf16le' && utf16Read.lines[0]?.text === '第一行' && utf16Read.lines[1]?.text === '第二行'
+  if (!utf16Ok) bad++
+  console.log(`${utf16Ok ? 'ok  ' : 'BAD '} utf16le round trip: bytes=${utf16.bytes} enc=${utf16Read.encoding} lines=${JSON.stringify(utf16Read.lines.map(l => l.text))}`)
+
+  // A UTF-8 BOM must be preserved by an edit, or the next reader misdetects it.
+  await engine.writeFile(alias, `${dir}\\bom.txt`, 'one\r\ntwo\r\n', 'utf8bom')
+  const bomEdit = await engine.editFile(alias, `${dir}\\bom.txt`, 'two', 'TWO', false)
+  const bomRead = await engine.readFile(alias, `${dir}\\bom.txt`, 1, 10)
+  const bomOk = bomEdit.encoding === 'utf8bom' && bomRead.encoding === 'utf8bom' && bomRead.lines[1]?.text === 'TWO'
+  if (!bomOk) bad++
+  console.log(`${bomOk ? 'ok  ' : 'BAD '} utf8bom preserved through an edit: edit=${bomEdit.encoding} read=${bomRead.encoding}`)
+
+  // A binary file has no line structure; the reader must say so instead of
+  // returning U+FFFD soup.
+  let binary = ''
+  try {
+    await engine.readFile(alias, 'C:\\Windows\\System32\\notepad.exe', 1, 5)
+  } catch (error) {
+    binary = error instanceof Error ? error.message : String(error)
+  }
+  const binaryOk = binary.length > 0
+  if (!binaryOk) bad++
+  console.log(`${binaryOk ? 'ok  ' : 'BAD '} binary read fails loudly: ${JSON.stringify(binary.slice(0, 120))}`)
+
+  let absent = ''
+  try {
+    await engine.readFile(alias, `${dir}\\nope.txt`, 1, 5)
+  } catch (error) {
+    absent = error instanceof Error ? error.message : String(error)
+  }
+  const absentOk = absent.includes('not found')
+  if (!absentOk) bad++
+  console.log(`${absentOk ? 'ok  ' : 'BAD '} read reports a missing file: ${JSON.stringify(absent)}`)
+
+  await runScript(conn, `Remove-Item -LiteralPath '${dir}' -Recurse -Force -ErrorAction SilentlyContinue`, { timeoutMs: 60_000 })
+}
+
 // Sanity: a script that never reaches the envelope must not claim success.
 {
   const r = await runScript(conn, `Write-Output 'ok'`, { timeoutMs: 60_000 })

package/src/client/index.ts

@@ -23,6 +23,7 @@ import type { MainPanelId } from '@deepseek-ai/dsh-client-ui-layout/client'
 import type {} from '@deepseek-ai/dsh-client-ui-sidebar/client'
 import { WinrmApi } from './api.ts'
 import { en, zh, type WinKey } from './locales.ts'
+import { WinrmEditCard, WinrmReadCard, WinrmWriteCard } from './tool/cards.tsx'
 import { WinrmPanel } from './panel/WinrmPanel.tsx'
 import { WinrmPanelIcon } from './panel/WinrmPanelIcon.tsx'
 
@@ -71,6 +72,22 @@ export function apply(ctx: ClientContext): void {
     inject: () => ({ api, onBack: () => { ctx.layout.selectPanel(null) } }),
   }, WinrmPanel))
 
+  // Transcript cards for the three remote file tools, keyed by wire tool name.
+  // Without an entry here each call renders as the generic tool row, so the
+  // user reads the same envelope text the model reads. The cards read the
+  // metadata the host persists with each result.
+  for (const [key, card] of [
+    ['winrm_read', WinrmReadCard],
+    ['winrm_write', WinrmWriteCard],
+    ['winrm_edit', WinrmEditCard],
+  ] as const) {
+    ctx.slots.inject('tool.call.toolview', () => ctx.slots.register({
+      name: 'tool.call.toolview',
+      key,
+      locale: NS,
+    }, card))
+  }
+
   // The sidebar row: an icon plus a localized label; selecting it opens the panel.
   ctx.slots.inject('sidebar.panellist', () => ctx.slots.register({
     name: 'sidebar.panellist',

package/src/client/locales.ts

@@ -114,6 +114,28 @@ export const zh = {
   'transfer.mib': 'MB',
   'transfer.dir': '目录',
   'transfer.file': '文件',
+  'tool.read': '读取远程文件',
+  'tool.write': '写入远程文件',
+  'tool.edit': '编辑远程文件',
+  'tool.running': '执行中…',
+  'tool.noDetail': '无卡片数据',
+  'tool.created': '新建 {bytes} 字节',
+  'tool.updated': '覆盖 {bytes} 字节',
+  'tool.replacements': '替换 {count} 处',
+  'tool.beyondBasis': '文件超过 diff 体积上限，仅显示路径',
+  'tool.truncatedByBytes': '已按字节上限截断',
+  'tool.truncatedLines': '{count} 行过长已截断',
+  'tool.codeLabel': '代码',
+  'tool.wrapLabel': '自动换行',
+  'tool.unwrapLabel': '取消自动换行',
+  'tool.window': '第 {shown} / {total} 行',
+  'tool.lines': '共 {count} 行',
+  'tool.copy': '复制',
+  'tool.copied': '已复制',
+  'tool.collapseAria': '收起',
+  'tool.expandAria': '展开剩余 {hidden} 行',
+  'tool.collapse': '收起',
+  'tool.expand': '展开其余 {hidden} 行',
 } as const
 
 export const en = {
@@ -227,6 +249,28 @@ export const en = {
   'transfer.mib': 'MB',
   'transfer.dir': 'dir',
   'transfer.file': 'file',
+  'tool.read': 'Read remote file',
+  'tool.write': 'Write remote file',
+  'tool.edit': 'Edit remote file',
+  'tool.running': 'Working…',
+  'tool.noDetail': 'No card data',
+  'tool.created': 'Created {bytes} bytes',
+  'tool.updated': 'Overwrote {bytes} bytes',
+  'tool.replacements': '{count} replacements',
+  'tool.beyondBasis': 'File is past the diff size cap; showing the path only',
+  'tool.truncatedByBytes': 'Cut at the byte budget',
+  'tool.truncatedLines': '{count} long lines truncated',
+  'tool.codeLabel': 'Code',
+  'tool.wrapLabel': 'Wrap lines',
+  'tool.unwrapLabel': 'Do not wrap',
+  'tool.window': '{shown} of {total} lines',
+  'tool.lines': '{count} lines',
+  'tool.copy': 'Copy',
+  'tool.copied': 'Copied',
+  'tool.collapseAria': 'Collapse',
+  'tool.expandAria': 'Expand the remaining {hidden} lines',
+  'tool.collapse': 'Collapse',
+  'tool.expand': 'Show the remaining {hidden} lines',
 } as const
 
 export type WinKey = keyof typeof zh

package/src/client/tool/card-model.ts

@@ -0,0 +1,151 @@
+/**
+ * Card models for the three remote file tools.
+ *
+ * The host projects a small JSON payload through `output.presentationMeta` and
+ * the session log persists it; these functions narrow that unknown payload into
+ * something the card components can hand to the harness's `ReadBlock` and
+ * `DiffBlock` primitives. Kept apart from the components so the narrowing can be
+ * unit tested without a DOM.
+ * @module dsh-winrm/src/client/tool/card-model
+ */
+
+/** One line of a read window. */
+export interface ReadCardLine {
+  number: number
+  text: string
+}
+
+/** A completed `winrm_read`: a line-numbered window of a remote file. */
+export interface ReadCard {
+  kind: 'read'
+  path: string
+  offset: number
+  lines: ReadCardLine[]
+  totalLines: number
+  encoding: string
+  truncatedByBytes: boolean
+  truncatedLines: number
+}
+
+/** One hunk of a remote write or edit, in the primitive's own shape. */
+export interface DiffHunk {
+  /** Prior fragment including shared context; `''` when the hunk had no prior content. */
+  oldText: string
+  /** Resulting fragment including the same shared context. */
+  newText: string
+}
+
+/** A completed `winrm_write` or `winrm_edit`: the changes it applied. */
+export interface DiffCard {
+  kind: 'diff'
+  /** Which tool produced it, so the header can name the operation. */
+  tool: 'write' | 'edit'
+  path: string
+  operation: 'create' | 'update'
+  bytes: number
+  size: number
+  replacements: number
+  encoding: string
+  hunks: DiffHunk[]
+  /** True when the previous text was past the basis cap, so no hunks exist. */
+  beyondBasis: boolean
+}
+
+/** A failed call: keeps the path and the message, drops card-specific detail. */
+export interface ErrorCard {
+  kind: 'error'
+  path: string
+  message: string
+}
+
+/** Any card these tools render. */
+export type FileCard = ReadCard | DiffCard | ErrorCard
+
+/** Read one string field, falling back when it is absent or the wrong type. */
+function str(source: Record<string, unknown>, key: string, fallback: string): string {
+  const value = source[key]
+  return typeof value === 'string' ? value : fallback
+}
+
+/** Read one finite number field, falling back when it is absent or not numeric. */
+function num(source: Record<string, unknown>, key: string, fallback: number): number {
+  const value = source[key]
+  return typeof value === 'number' && Number.isFinite(value) ? value : fallback
+}
+
+/** Read one boolean field, defaulting to `false`. */
+function bool(source: Record<string, unknown>, key: string): boolean {
+  return source[key] === true
+}
+
+/** Narrow an unknown value to a plain record. */
+function record(value: unknown): Record<string, unknown> | undefined {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+    ? value as Record<string, unknown>
+    : undefined
+}
+
+/**
+ * Narrow a `winrm_read` metadata payload into a card.
+ * @param meta - the persisted payload, of unknown shape.
+ * @param fallbackPath - the authored path, used when the payload omits one.
+ * @returns the card, or `undefined` when the payload is not a read card.
+ */
+export function readCard(meta: unknown, fallbackPath: string): FileCard | undefined {
+  const source = record(meta)
+  if (source === undefined || source.card !== 'winrm-read') return undefined
+  const path = str(source, 'path', fallbackPath)
+  const error = str(source, 'error', '')
+  if (error !== '') return { kind: 'error', path, message: error }
+  const rawLines = Array.isArray(source.lines) ? source.lines : []
+  const lines: ReadCardLine[] = []
+  for (const entry of rawLines) {
+    const line = record(entry)
+    if (line === undefined) continue
+    lines.push({ number: num(line, 'number', lines.length + 1), text: str(line, 'text', '') })
+  }
+  return {
+    kind: 'read',
+    path,
+    offset: num(source, 'offset', 1),
+    lines,
+    totalLines: num(source, 'totalLines', lines.length),
+    encoding: str(source, 'encoding', 'utf8'),
+    truncatedByBytes: bool(source, 'truncatedByBytes'),
+    truncatedLines: num(source, 'truncatedLines', 0),
+  }
+}
+
+/**
+ * Narrow a `winrm_write` / `winrm_edit` metadata payload into a card.
+ * @param meta - the persisted payload, of unknown shape.
+ * @param fallbackPath - the authored path, used when the payload omits one.
+ * @param tool - which tool produced the payload.
+ * @returns the card, or `undefined` when the payload belongs to another card.
+ */
+export function diffCard(meta: unknown, fallbackPath: string, tool: 'write' | 'edit'): FileCard | undefined {
+  const source = record(meta)
+  if (source === undefined || source.card !== `winrm-${tool}`) return undefined
+  const path = str(source, 'path', fallbackPath)
+  const error = str(source, 'error', '')
+  if (error !== '') return { kind: 'error', path, message: error }
+  const rawDiffs = Array.isArray(source.diffs) ? source.diffs : []
+  const hunks: DiffHunk[] = []
+  for (const entry of rawDiffs) {
+    const hunk = record(entry)
+    if (hunk === undefined) continue
+    hunks.push({ oldText: str(hunk, 'oldText', ''), newText: str(hunk, 'newText', '') })
+  }
+  return {
+    kind: 'diff',
+    tool,
+    path,
+    operation: source.operation === 'create' ? 'create' : 'update',
+    bytes: num(source, 'bytes', 0),
+    size: num(source, 'size', 0),
+    replacements: num(source, 'replacements', 0),
+    encoding: str(source, 'encoding', 'utf8'),
+    hunks,
+    beyondBasis: bool(source, 'beyondBasis'),
+  }
+}

package/src/client/tool/cards.module.css

@@ -0,0 +1,128 @@
+/*
+ * Only the pieces this plugin draws itself: the failed-call row, the collapsed
+ * header line, and the summary note under a card. The card bodies are the
+ * harness's own `ReadBlock` / `DiffBlock` primitives, which carry their own
+ * styles.
+ *
+ * The header line copies the measurements of the harness's own tool rows
+ * (`ui-tool`'s `ToolRow.module.css`) rather than approximating them, so a
+ * remote file row sits in the transcript exactly like a local one:
+ * `[16 leading] gap6 [title] gap8 [2px dot] gap8 [path fill] [trailing figure]`.
+ */
+
+/* Hover scope for the trailing +/- totals: the harness tints them only while
+   the row is hovered or expanded, keeping a quiet transcript quiet. */
+.wrap {
+  display: flex;
+  flex-direction: column;
+  min-width: 0;
+}
+
+.wrap:hover .added,
+.wrap:focus-within .added {
+  color: var(--dsw-alias-state-success-primary);
+}
+
+.wrap:hover .removed,
+.wrap:focus-within .removed {
+  color: var(--dsw-alias-state-error-primary);
+}
+
+/* The separator between the verb and the path: a 2px dot, not a character, so
+   it never picks up the text font's metrics. */
+.sep {
+  flex: none;
+  width: 2px;
+  height: 2px;
+  border-radius: 1px;
+  margin: 0 8px;
+  background: var(--dsw-alias-label-caption);
+}
+
+/* The remote path hugs its text and clips when the row is narrow, so the
+   trailing figure reads as part of the same sentence instead of being pushed to
+   the far edge of a wide row. Same treatment the harness gives a file path. */
+.summary {
+  flex: 0 1 auto;
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  font-size: var(--dsh-content-font-size-secondary, 13px);
+  line-height: calc(24px + var(--dsh-content-font-delta, 0px));
+  font-variant-numeric: tabular-nums;
+}
+
+/* Trailing figure kept outside the path's ellipsis: a line count or a status
+   word whose whole value is that it survives a narrow row. */
+.meta {
+  flex: none;
+  margin-left: 8px;
+  white-space: nowrap;
+  font-size: var(--dsh-content-font-size-secondary, 13px);
+  line-height: calc(24px + var(--dsh-content-font-delta, 0px));
+  font-variant-numeric: tabular-nums;
+}
+
+/* The `+n -m` figure a write or edit row shows beside its path: the code font,
+   matching the diff body it summarizes, two px under the secondary tier
+   because mono digits read optically larger than the sans path. */
+.diffStat {
+  flex: none;
+  margin-left: 10px;
+  white-space: nowrap;
+  font-family: var(--ds-font-family-code);
+  font-size: calc(var(--dsh-content-font-size-secondary, 13px) - 2px);
+  line-height: calc(24px + var(--dsh-content-font-delta, 0px));
+  transform: translateY(0.5px);
+  font-variant-numeric: tabular-nums;
+}
+
+.added,
+.removed {
+  color: inherit;
+}
+
+/* One-line row for a call that failed: the message replaces the card. */
+.rowError {
+  display: flex;
+  align-items: baseline;
+  gap: 8px;
+  padding: 2px 0;
+  font-family: var(--dsw-font-family);
+  font-size: 12px;
+  line-height: 1.55;
+}
+
+.title {
+  flex: none;
+  color: var(--dsw-alias-label-secondary);
+}
+
+.detail {
+  min-width: 0;
+  color: var(--dsw-alias-label-tertiary);
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.rowError .title {
+  color: var(--dsw-alias-state-error-primary);
+}
+
+.rowError .detail {
+  color: var(--dsw-alias-state-error-primary);
+  white-space: normal;
+  overflow-wrap: anywhere;
+}
+
+/* The note under an expanded card: encoding, truncation, replacement count. */
+.note {
+  padding: 4px 0 0;
+  color: var(--dsw-alias-label-tertiary);
+  font-family: var(--dsw-font-family);
+  font-size: 12px;
+  line-height: 1.55;
+  font-variant-numeric: tabular-nums;
+}