dsh-oc-tui 0.2.0 → 0.3.0

package/lib/markdown.js

@@ -11,7 +11,7 @@
 import MarkdownIt from 'markdown-it'
 import hljs from 'highlight.js'
 import { makeStyle, mergeStyle } from './term.js'
-import { runeWidth, displayWidth } from './util.js'
+import { runeWidth, displayWidth, truncateWidth } from './util.js'
 
 const md = new MarkdownIt({ html: false, linkify: true, typographer: false })
 
@@ -54,8 +54,11 @@ function parseHljsHtml(html, theme, base) {
     if (m[1] !== undefined) classes.push(m[1])
     else if (m[0] === '</span>') classes.pop()
     else {
-      const scope = (classes.find((c) => c && c !== 'hljs') ?? '').replace(/^hljs-/, '').replace(/_.*$/, '')
-      const key = HLJS_COLOR_KEYS[scope]
+      let key
+      for (let i = classes.length - 1; i >= 0 && !key; i--) {
+        const scope = classes[i].split(/\s+/)[0].replace(/^hljs-/, '')
+        key = HLJS_COLOR_KEYS[scope]
+      }
       const fg = key ? (theme[key] ?? theme.markdownCodeBlock) : theme.markdownCodeBlock
       segs.push({ text: decodeEntities(m[2]), style: mergeStyle(base, { fg, bg: theme.codeBg }) })
     }
@@ -86,6 +89,85 @@ function highlightLines(code, lang, theme, base) {
   return lines
 }
 
+function expandCodeTabs(code) {
+  let column = 0
+  let out = ''
+  for (const ch of code) {
+    if (ch === '\n') {
+      out += ch
+      column = 0
+    } else if (ch === '\t') {
+      const spaces = 4 - column % 4
+      out += ' '.repeat(spaces)
+      column += spaces
+    } else {
+      out += ch
+      column += runeWidth(ch)
+    }
+  }
+  return out
+}
+
+// Wrap by cells without dropping indentation or spaces between styled runs.
+const codeGraphemes = new Intl.Segmenter('en', { granularity: 'grapheme' })
+
+function wrapCodeLine(segs, width) {
+  const lines = [[]]
+  let used = 0
+  for (const seg of segs) {
+    let text = ''
+    const flush = () => {
+      if (text) lines[lines.length - 1].push({ ...seg, text })
+      text = ''
+    }
+    const cells = /[\p{Mark}\u200d\u{1f1e6}-\u{1f1ff}\u{1f3fb}-\u{1f3ff}]/u.test(seg.text)
+      ? Array.from(codeGraphemes.segment(seg.text), (item) => item.segment)
+      : seg.text
+    for (const segment of cells) {
+      let w = segWidth(segment)
+      if (used + w > width && used > 0) {
+        flush()
+        lines.push([])
+        used = 0
+      }
+      if (w > width) {
+        text += '�'
+        w = 1
+      } else text += segment
+      used += w
+    }
+    flush()
+  }
+  return lines
+}
+
+function renderCodeBlock(ctx, state, code, lang) {
+  const theme = ctx.theme
+  const codeBase = makeStyle({ fg: theme.markdownCodeBlock, bg: theme.codeBg })
+  const prefix = truncateWidth(prefixOf(state), Math.max(0, ctx.width - 1))
+  const prefixWidth = displayWidth(prefix)
+  const inset = ' '.repeat(Math.min(2, Math.max(0, ctx.width - prefixWidth - 2)))
+  const innerWidth = ctx.width - prefixWidth - inset.length
+  const contentWidth = innerWidth > 2 ? innerWidth - 1 : innerWidth
+  const emit = (line) => {
+    const used = line.reduce((sum, seg) => sum + segWidth(seg.text), 0)
+    const row = []
+    if (prefix) row.push({ text: prefix, style: state.quoteStyle ?? null })
+    if (inset) row.push({ text: inset, style: codeBase })
+    row.push(...line)
+    if (innerWidth > used) row.push({ text: ' '.repeat(innerWidth - used), style: codeBase })
+    ctx.lines.push(row)
+  }
+  ctx.lines.push([])
+  if (lang) {
+    emit([{ text: truncateWidth(lang, contentWidth), style: makeStyle({ fg: theme.textMuted, bg: theme.codeBg, bold: true }) }])
+  }
+  for (const line of highlightLines(expandCodeTabs(code.replace(/\n$/, '')), lang, theme, codeBase)) {
+    for (const wrapped of wrapCodeLine(line, contentWidth)) emit(wrapped)
+  }
+  ctx.lines.push([])
+}
+
 // Render an inline token's children to flat segments. Style state (bold, em,
 // strike) and the enclosing link ride a stack; link segments carry the href on
 // a `link` property, which paint() turns into an OSC 8 hyperlink.
@@ -170,26 +252,18 @@ function clipSegLine(segs, width) {
   const out = []
   let used = 0
   for (const seg of segs) {
-    if (used >= width) break
-    const w = segWidth(seg.text)
-    if (used + w <= width) {
-      out.push(seg)
-      used += w
-      continue
-    }
-    const room = width - used - 1
-    if (room < 0) {
-      if (out.length === 0) out.push({ ...seg, text: '…' })
-      break
-    }
     let text = ''
     for (const ch of seg.text) {
-      if (segWidth(text) + runeWidth(ch) > room) break
+      const w = runeWidth(ch)
+      if (used + w > width - 1) {
+        if (text) out.push({ ...seg, text })
+        out.push({ ...seg, text: '…' })
+        return out
+      }
       text += ch
+      used += w
     }
     if (text) out.push({ ...seg, text })
-    out.push({ ...seg, text: '…' })
-    used = width
   }
   return out
 }
@@ -214,8 +288,9 @@ function tableBoxRow(cells, widths, theme) {
   const segs = [{ text: '│', style }]
   cells.forEach((cell, i) => {
     segs.push({ text: ' ', style })
-    segs.push(...clipSegLine(cell, widths[i]))
-    const pad = widths[i] - cell.reduce((w, s) => w + segWidth(s.text), 0)
+    const clipped = clipSegLine(cell, widths[i])
+    segs.push(...clipped)
+    const pad = widths[i] - clipped.reduce((w, s) => w + segWidth(s.text), 0)
     if (pad > 0) segs.push({ text: ' '.repeat(pad), style })
     segs.push({ text: ' ', style })
     if (i < cells.length - 1) segs.push({ text: '│', style })
@@ -356,13 +431,12 @@ function renderBlocks(tokens, start, end, ctx, state) {
           i += 1
           continue
         }
-        const codeBase = makeStyle({ fg: theme.markdownCodeBlock, bg: theme.codeBg })
-        const prefix = prefixOf(state) + '  '
-        ctx.lines.push([])
-        for (const line of highlightLines(t.content.replace(/\n$/, ''), lang, theme, codeBase)) {
-          ctx.lines.push([{ text: prefix, style: codeBase }, ...line])
-        }
-        ctx.lines.push([])
+        renderCodeBlock(ctx, state, t.content, lang)
+        i += 1
+        continue
+      }
+      case 'code_block': {
+        renderCodeBlock(ctx, state, t.content, '')
         i += 1
         continue
       }

package/lib/mcp-monitor.js

@@ -0,0 +1,189 @@
+// MCP connection state for the TUI, and the output isolation that keeps a
+// failed MCP server off the screen.
+//
+// The host's MCP client reports a server it cannot reach by writing to the
+// terminal, and a stdio server inherits the terminal's stderr, so adding an
+// MCP server whose program is not running leaves stray text on the frame the
+// renderer owns — the TUI then paints over a screen that never settled. This
+// module diverts that output and reports the state instead: once per state,
+// as a short notice in the corner.
+import childProcess from 'node:child_process'
+
+// The host prints one multiline audit after startup: the plugins that did not
+// activate, each with its reason and a stack. Only the MCP entries are
+// dropped; any other plugin's diagnostics are left alone.
+export function filterMcpStartupAudit(text) {
+  const lines = text.split('\n')
+  const header = /^(.*?: warning: )\d+ entr(?:y|ies) did not activate$/.exec(lines[0])
+  if (!header || !text.includes('@deepseek-ai/dsh-mcp-client')) return text
+  const blocks = []
+  for (const line of lines.slice(1)) {
+    if (!line && blocks.length === 0) continue
+    if (/^\S.* \([^)]+\): /.test(line)) blocks.push([line])
+    else if (blocks.length) blocks.at(-1).push(line)
+    else return text
+  }
+  if (!blocks.some((block) => block[0].includes('(@deepseek-ai/dsh-mcp-client)'))) return text
+  const kept = blocks.filter((block) => !block[0].includes('(@deepseek-ai/dsh-mcp-client)'))
+  if (!kept.length) return ''
+  return `${header[1]}${kept.length} ${kept.length === 1 ? 'entry' : 'entries'} did not activate\n${kept.map((block) => block.join('\n').replace(/\n+$/, '')).join('\n')}\n`
+}
+
+// Wrap the current `process.stderr.write` so an MCP startup audit never
+// reaches the terminal. The wrapper is installed around whatever writer is
+// current — the raw stream before the alt screen, the diagnostics capture
+// after it — so it composes instead of competing with it.
+export function filterMcpStderrWrites() {
+  const original = process.stderr.write
+  function stderrWrite(chunk, encoding, callback) {
+    if (typeof chunk !== 'string' && !Buffer.isBuffer(chunk)) return original.apply(this, arguments)
+    const text = Buffer.isBuffer(chunk) ? chunk.toString(typeof encoding === 'string' ? encoding : 'utf8') : chunk
+    const filtered = filterMcpStartupAudit(text)
+    if (filtered === text) return original.apply(this, arguments)
+    if (filtered) return original.call(this, filtered, encoding, callback)
+    const done = typeof encoding === 'function' ? encoding : callback
+    if (typeof done === 'function') queueMicrotask(done)
+    return true
+  }
+  process.stderr.write = stderrWrite
+  return () => {
+    if (process.stderr.write === stderrWrite) process.stderr.write = original
+  }
+}
+
+// Keep MCP diagnostics out of the terminal:
+//
+//   * a stdio server spawned by the SDK inherits stderr, so its own output
+//     lands on the frame. Only the SDK's transport spawn is redirected, never
+//     an ordinary tool process;
+//   * the SDK writes its own diagnostics straight to the console (for example
+//     when a server advertises no tools).
+export function isolateMcpOutput() {
+  const original = childProcess.spawn
+  const consoleMethods = new Map()
+  for (const name of ['log', 'info', 'warn', 'error', 'debug']) {
+    const previous = console[name]
+    function filtered(...args) {
+      if (/[\\/]@modelcontextprotocol[\\/]/.test(new Error().stack || '')) return
+      return previous.apply(this, args)
+    }
+    consoleMethods.set(name, { previous, filtered })
+    console[name] = filtered
+  }
+  function spawn(command, args, options) {
+    const stdio = options?.stdio
+    const isMcp = Array.isArray(stdio) && stdio[0] === 'pipe' && stdio[1] === 'pipe'
+      && stdio[2] === 'inherit' && /StdioClientTransport\.start/.test(new Error().stack || '')
+    if (!isMcp) return original.apply(this, arguments)
+    const child = original.call(this, command, args, { ...options, stdio: [stdio[0], stdio[1], 'pipe', ...stdio.slice(3)] })
+    // Drain immediately: an unread pipe can block a noisy server. Its output
+    // is diagnostic text, not a reliable indication of connection state.
+    child.stderr?.resume()
+    return child
+  }
+  childProcess.spawn = spawn
+  return () => {
+    if (childProcess.spawn === spawn) childProcess.spawn = original
+    for (const [name, { previous, filtered }] of consoleMethods) {
+      if (console[name] === filtered) console[name] = previous
+    }
+  }
+}
+
+// Watch the host's MCP client and report each server's state. The state is
+// read from two places: the host's log lines, and the plugin fibers of
+// `@deepseek-ai/dsh-mcp-client` (which know whether a server came up).
+export function createMcpMonitor(ctx) {
+  const state = new Map()
+  const seenLoading = new WeakSet()
+  const probes = new Map()
+  const pending = []
+  let listener = null
+  const report = (name, status) => {
+    if (!name || state.get(name) === status) return
+    state.set(name, status)
+    const event = { name, status }
+    if (listener) listener(event)
+    else pending.push(event)
+  }
+  const handleLog = (message) => {
+    const text = String(message?.args?.[0] ?? '')
+    const match = /^mcp-client\(([^)]+)\):\s*(.*)/s.exec(text)
+    if (!match) return
+    const detail = match[2]
+    if (/connection attempt failed|connection failed|connection lost|giving up|failed generation|tool registration failed/i.test(detail)) report(match[1], 'failed')
+    else if (/reconnected and re-synced/i.test(detail)) report(match[1], 'connected')
+  }
+  const handleFiber = (fiber) => {
+    const entry = fiber?.entry
+    if (!entry || !String(entry.options?.name ?? '').includes('dsh-mcp-client')) return
+    // Effects created by a plugin inherit its entry but become active before
+    // the plugin's asynchronous connection attempt has settled.
+    if (entry.fiber !== fiber) return
+    const server = entry.options?.config?.serverName
+    if (!server) return
+    if (fiber.state === 1) {
+      seenLoading.add(fiber)
+      probes.delete(server)
+      state.delete(server)
+    }
+    // A host MCP plugin can activate after a failed first attempt while its
+    // retry supervisor runs, so a failure log takes precedence over ACTIVE.
+    if (fiber.state === 2 && !state.has(server)) {
+      const resources = ctx.get('mcpResources')
+      if (typeof resources?.request === 'function') {
+        // The provider checks its connection before handling a request.
+        // An already-aborted signal keeps this probe local to the host.
+        const probe = {}
+        probes.set(server, probe)
+        const signal = AbortSignal.abort()
+        Promise.resolve().then(() => resources.request(server, { method: 'resources/read', uri: 'tui-status://probe' }, { agent: undefined, signal }))
+          .then(() => 'connected', (error) => {
+            const text = String(error)
+            if (/server is disconnected/i.test(text)) return 'failed'
+            if (/unavailable in this agent's scope/i.test(text)) return null
+            return 'connected'
+          }).then((status) => {
+            if (probes.get(server) === probe && !state.has(server) && status) report(server, status)
+          })
+      } else if (seenLoading.has(fiber)) {
+        // If observation began before this fiber loaded, its failure logs
+        // would have arrived before the ACTIVE transition.
+        report(server, 'connected')
+      }
+    }
+    if (fiber.state === 3) report(server, 'failed')
+  }
+  ctx.logger.exporter({ levels: { default: 2 }, export: handleLog })
+  ctx.on('internal/status', handleFiber, { global: true })
+  for (const entry of ctx.get('loader')?.entries?.() ?? []) if (entry.fiber) handleFiber(entry.fiber)
+  return {
+    attach(fn) { listener = fn; for (const event of pending.splice(0)) fn(event) },
+    detach() { listener = null },
+    handleLog, handleFiber,
+  }
+}
+
+// One gate for every source of MCP state (the host's log, the host's plugin
+// fibers, the TUI's own mounts): a server that reports the same state twice
+// is reported once. The state changes on the next attempt, so a reconnect
+// that succeeds is reported again.
+export function createMcpNotifier() {
+  const state = new Map()
+  const listeners = new Set()
+  return {
+    report(name, status) {
+      if (!name) return
+      const key = String(name)
+      if (state.get(key) === status) return
+      state.set(key, status)
+      for (const listener of listeners) {
+        try { listener(key, status) } catch { /* a listener must not break the notifier */ }
+      }
+    },
+    subscribe(fn) {
+      listeners.add(fn)
+      return () => { listeners.delete(fn) }
+    },
+  }
+}

package/lib/mcp-skill.js

@@ -1,93 +1,93 @@
-// The bundled `mcp-import` skill: the shipped SKILL.md parsed into the shape the
-// host's skill registry accepts, and registered on the optional `skills` service.
-//
-// The skill service is a harness capability, not a dependency of this plugin: a
-// host without a skill registry must still boot the TUI, so every entry point
-// here answers with a verdict instead of throwing, and nothing imports
-// `@deepseek-ai/*` at module scope — that specifier may not resolve at all.
-
-import { readFileSync } from 'node:fs'
-import { fileURLToPath } from 'node:url'
-import { formatError } from './util.js'
-
-export const MCP_SKILL_NAME = 'mcp-import'
-
-// Resolved from this module, not from process.cwd(), so the skill is found
-// wherever the tarball was unpacked.
-const SKILL_FILE = new URL('../skills/mcp-import/SKILL.md', import.meta.url)
-const SKILL_DIR = fileURLToPath(new URL('../skills/mcp-import/', import.meta.url))
-
-// The frontmatter this project writes: a `---` fence, `key: value` scalars, a
-// closing fence. Only those scalars are read; the host parses the real YAML when
-// the skill is discovered from disk, this parser only feeds the runtime channel.
-function scalar(text) {
-  const value = text.trim()
-  if (value.length >= 2 && (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'"))) {
-    const inner = value.slice(1, -1)
-    return value[0] === '"' ? inner.replace(/\\(["\\])/g, '$1') : inner.replace(/''/g, "'")
-  }
-  return value
-}
-
-export function parseSkillFile(text) {
-  if (typeof text !== 'string') return null
-  const lines = text.replace(/^\uFEFF/, '').split(/\r?\n/)
-  if (lines[0]?.trim() !== '---') return null
-  let end = -1
-  for (let index = 1; index < lines.length; index++) {
-    if (lines[index].trim() === '---') { end = index; break }
-  }
-  if (end < 0) return null
-  const fields = {}
-  for (const line of lines.slice(1, end)) {
-    const match = /^([A-Za-z0-9_-]+)\s*:\s*(.*)$/.exec(line.trim())
-    if (match) fields[match[1]] = scalar(match[2])
-  }
-  if (!fields.name || !fields.description) return null
-  const skill = {
-    name: fields.name,
-    description: fields.description,
-    content: lines.slice(end + 1).join('\n').trim(),
-  }
-  if (fields.whenToUse) skill.whenToUse = fields.whenToUse
-  return skill
-}
-
-export function loadBundledMcpSkill() {
-  try {
-    return parseSkillFile(readFileSync(SKILL_FILE, 'utf8'))
-  } catch {
-    return null
-  }
-}
-
-// Returns a verdict rather than throwing: a host without the service, a broken
-// bundled file and a rejecting registry all have to leave the TUI running.
-export function registerMcpSkill(ctx) {
-  let skills
-  try {
-    skills = ctx?.get?.('skills')
-  } catch (error) {
-    return { ok: false, reason: 'skills lookup failed: ' + formatError(error) }
-  }
-  if (!skills || typeof skills.register !== 'function') {
-    return { ok: false, reason: 'the host skill service is unavailable' }
-  }
-  const skill = loadBundledMcpSkill()
-  if (!skill) return { ok: false, reason: 'the bundled ' + MCP_SKILL_NAME + ' skill could not be read' }
-  const registration = {
-    name: skill.name,
-    description: skill.description,
-    content: skill.content,
-    source: 'bundled',
-    resourceBase: { kind: 'directory', path: SKILL_DIR },
-    invocation: { modelInvocable: true, userInvocable: true },
-  }
-  if (skill.whenToUse) registration.whenToUse = skill.whenToUse
-  try {
-    skills.register(registration)
-    return { ok: true, name: skill.name }
-  } catch (error) {
-    return { ok: false, reason: 'skill registration failed: ' + formatError(error) }
-  }
-}
+// The bundled `mcp-import` skill: the shipped SKILL.md parsed into the shape the
+// host's skill registry accepts, and registered on the optional `skills` service.
+//
+// The skill service is a harness capability, not a dependency of this plugin: a
+// host without a skill registry must still boot the TUI, so every entry point
+// here answers with a verdict instead of throwing, and nothing imports
+// `@deepseek-ai/*` at module scope — that specifier may not resolve at all.
+
+import { readFileSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+import { formatError } from './util.js'
+
+export const MCP_SKILL_NAME = 'mcp-import'
+
+// Resolved from this module, not from process.cwd(), so the skill is found
+// wherever the tarball was unpacked.
+const SKILL_FILE = new URL('../skills/mcp-import/SKILL.md', import.meta.url)
+const SKILL_DIR = fileURLToPath(new URL('../skills/mcp-import/', import.meta.url))
+
+// The frontmatter this project writes: a `---` fence, `key: value` scalars, a
+// closing fence. Only those scalars are read; the host parses the real YAML when
+// the skill is discovered from disk, this parser only feeds the runtime channel.
+function scalar(text) {
+  const value = text.trim()
+  if (value.length >= 2 && (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'"))) {
+    const inner = value.slice(1, -1)
+    return value[0] === '"' ? inner.replace(/\\(["\\])/g, '$1') : inner.replace(/''/g, "'")
+  }
+  return value
+}
+
+export function parseSkillFile(text) {
+  if (typeof text !== 'string') return null
+  const lines = text.replace(/^\uFEFF/, '').split(/\r?\n/)
+  if (lines[0]?.trim() !== '---') return null
+  let end = -1
+  for (let index = 1; index < lines.length; index++) {
+    if (lines[index].trim() === '---') { end = index; break }
+  }
+  if (end < 0) return null
+  const fields = {}
+  for (const line of lines.slice(1, end)) {
+    const match = /^([A-Za-z0-9_-]+)\s*:\s*(.*)$/.exec(line.trim())
+    if (match) fields[match[1]] = scalar(match[2])
+  }
+  if (!fields.name || !fields.description) return null
+  const skill = {
+    name: fields.name,
+    description: fields.description,
+    content: lines.slice(end + 1).join('\n').trim(),
+  }
+  if (fields.whenToUse) skill.whenToUse = fields.whenToUse
+  return skill
+}
+
+export function loadBundledMcpSkill() {
+  try {
+    return parseSkillFile(readFileSync(SKILL_FILE, 'utf8'))
+  } catch {
+    return null
+  }
+}
+
+// Returns a verdict rather than throwing: a host without the service, a broken
+// bundled file and a rejecting registry all have to leave the TUI running.
+export function registerMcpSkill(ctx) {
+  let skills
+  try {
+    skills = ctx?.get?.('skills')
+  } catch (error) {
+    return { ok: false, reason: 'skills lookup failed: ' + formatError(error) }
+  }
+  if (!skills || typeof skills.register !== 'function') {
+    return { ok: false, reason: 'the host skill service is unavailable' }
+  }
+  const skill = loadBundledMcpSkill()
+  if (!skill) return { ok: false, reason: 'the bundled ' + MCP_SKILL_NAME + ' skill could not be read' }
+  const registration = {
+    name: skill.name,
+    description: skill.description,
+    content: skill.content,
+    source: 'bundled',
+    resourceBase: { kind: 'directory', path: SKILL_DIR },
+    invocation: { modelInvocable: true, userInvocable: true },
+  }
+  if (skill.whenToUse) registration.whenToUse = skill.whenToUse
+  try {
+    skills.register(registration)
+    return { ok: true, name: skill.name }
+  } catch (error) {
+    return { ok: false, reason: 'skill registration failed: ' + formatError(error) }
+  }
+}