dsh-oc-tui 0.2.0 → 0.3.0

package/lib/screenshot.js

@@ -0,0 +1,140 @@
+import { execFile } from 'node:child_process'
+import { mkdir, readFile, writeFile } from 'node:fs/promises'
+import { homedir, platform } from 'node:os'
+import { isAbsolute, join, resolve } from 'node:path'
+import { promisify } from 'node:util'
+
+const execFileAsync = promisify(execFile)
+let picturesDirectory
+
+export function defaultPicturesDirectory() {
+  if (!picturesDirectory) picturesDirectory = findPicturesDirectory()
+  return picturesDirectory
+}
+
+async function findPicturesDirectory() {
+  const home = homedir()
+  if (platform() === 'win32') {
+    try {
+      const { stdout } = await execFileAsync('powershell.exe', [
+        '-NoProfile', '-NonInteractive', '-Command',
+        '[Console]::OutputEncoding = [System.Text.UTF8Encoding]::new(); [Environment]::GetFolderPath("MyPictures")',
+      ], { timeout: 4000, windowsHide: true })
+      const directory = stdout.trim()
+      if (directory && isAbsolute(directory)) return directory
+    } catch { /* Windows can still use the conventional folder. */ }
+  } else if (platform() !== 'darwin') {
+    try {
+      const config = await readFile(join(process.env.XDG_CONFIG_HOME || join(home, '.config'), 'user-dirs.dirs'), 'utf8')
+      const match = /^XDG_PICTURES_DIR="([^"\r\n]*)"/m.exec(config)
+      const directory = match?.[1]?.replace(/^\$HOME(?=\/|$)/, home)
+      if (directory && isAbsolute(directory)) return directory
+    } catch { /* XDG user directories are optional. */ }
+  }
+  return join(home, 'Pictures')
+}
+
+function escapeXml(value) {
+  return String(value).replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f-\u009f]/g, '\ufffd')
+    .replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;').replace(/'/g, '&apos;')
+}
+
+function color(value, fallback) {
+  if (typeof value !== 'string') return fallback
+  const hex = value.replace(/^#/, '')
+  if (/^[0-9a-f]{6}$/i.test(hex)) return '#' + hex
+  if (/^[0-9a-f]{3}$/i.test(hex)) return '#' + [...hex].map((ch) => ch + ch).join('')
+  return fallback
+}
+
+// The export is reconstructed from the same cells the terminal receives, so it
+// works over SSH and does not require access to the user's desktop or clipboard.
+export async function renderScreenshot(screen, { title = '', images = new Map() } = {}) {
+  const sharp = (await import('sharp')).default
+  const cellW = 10
+  const cellH = 20
+  const margin = 24
+  const titleH = 40
+  const width = screen.cols * cellW + margin * 2
+  const height = screen.rows * cellH + margin * 2 + titleH
+  if (width * height > 50_000_000) throw new Error('screen is too large to export')
+  const x0 = margin
+  const y0 = margin + titleH
+  const windowW = screen.cols * cellW
+  const windowH = titleH + screen.rows * cellH
+  const pieces = [
+    `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}">`,
+    `<rect x="${x0}" y="${margin}" width="${windowW}" height="${windowH}" rx="7" fill="#151620" stroke="#373b53"/>`,
+    `<path d="M${x0} ${margin + titleH}H${x0 + windowW}" stroke="#303347"/>`,
+    `<circle cx="${x0 + 18}" cy="${margin + 20}" r="5" fill="#ff5f57"/>`,
+    `<circle cx="${x0 + 35}" cy="${margin + 20}" r="5" fill="#febc2e"/>`,
+    `<circle cx="${x0 + 52}" cy="${margin + 20}" r="5" fill="#28c840"/>`,
+    `<clipPath id="title"><rect x="${x0 + 69}" y="${margin}" width="${Math.max(0, windowW - 80)}" height="${titleH}"/></clipPath>`,
+    `<text x="${x0 + 70}" y="${margin + 25}" clip-path="url(#title)" fill="#a8b4d2" font-family="Cascadia Mono,Consolas,Microsoft YaHei UI,monospace" font-size="13">${escapeXml(title)}</text>`,
+  ]
+  for (let y = 0; y < screen.rows; y++) {
+    const row = screen.cells[y]
+    for (let x = 0; x < screen.cols;) {
+      const bg = color(row[x].style?.bg, '#101114')
+      let end = x + 1
+      while (end < screen.cols && color(row[end].style?.bg, '#101114') === bg) end++
+      pieces.push(`<rect x="${x0 + x * cellW}" y="${y0 + y * cellH}" width="${(end - x) * cellW}" height="${cellH}" fill="${bg}"/>`)
+      x = end
+    }
+    for (let x = 0; x < screen.cols; x++) {
+      const cell = row[x]
+      const ch = cell.ch
+      if (!ch || ch === ' ') continue
+      const style = cell.style ?? {}
+      const fg = color(style.fg, '#e4e5eb')
+      const px = x0 + x * cellW
+      const py = y0 + y * cellH
+      if (ch === '▀' || ch === '▄' || ch === '█') {
+        const top = ch === '▄' ? cellH / 2 : 0
+        const h = ch === '█' ? cellH : cellH / 2
+        pieces.push(`<rect x="${px}" y="${py + top}" width="${cellW}" height="${h}" fill="${fg}"/>`)
+      } else {
+        const weight = style.bold ? 'bold' : 'normal'
+        const italic = style.italic ? 'italic' : 'normal'
+        const opacity = style.dim ? '0.65' : '1'
+        const underline = style.underline ? ' text-decoration="underline"' : ''
+        pieces.push(`<text x="${px}" y="${py + 16}" fill="${fg}" opacity="${opacity}" font-family="Cascadia Mono,Consolas,Microsoft YaHei UI,Noto Sans Mono CJK SC,monospace" font-size="16" font-weight="${weight}" font-style="${italic}"${underline}>${escapeXml(ch)}</text>`)
+      }
+    }
+  }
+  pieces.push('</svg>')
+  const imageLayers = []
+  for (const image of screen.images ?? []) {
+    const payload = images.get(image.key)
+    const bytes = payload?.png ?? (payload?.b64 ? Buffer.from(payload.b64, 'base64') : null)
+    if (!bytes) continue
+    const imageW = Math.max(1, image.cellsW * cellW)
+    const imageH = Math.max(1, image.cellsH * cellH)
+    const visibleW = Math.min(imageW, (screen.cols - image.x) * cellW)
+    const visibleH = Math.min(imageH, (screen.rows - image.y) * cellH)
+    if (image.x < 0 || image.y < 0 || visibleW <= 0 || visibleH <= 0) continue
+    const input = await sharp(bytes).resize(imageW, imageH, { fit: 'fill' })
+      .extract({ left: 0, top: 0, width: visibleW, height: visibleH }).png().toBuffer()
+    imageLayers.push({ input, left: x0 + image.x * cellW, top: y0 + image.y * cellH })
+  }
+  return sharp(Buffer.from(pieces.join(''))).composite(imageLayers).png().toBuffer()
+}
+
+export async function saveScreenshot(screen, { directory, title, images, now = new Date() } = {}) {
+  const choice = typeof directory === 'string' ? directory.trim() : ''
+  const expanded = choice === '~' ? homedir() : choice.replace(/^~[\\/]/, homedir() + '/')
+  const target = expanded ? resolve(expanded) : await defaultPicturesDirectory()
+  const png = await renderScreenshot(screen, { title, images })
+  await mkdir(target, { recursive: true })
+  const stamp = now.toISOString().replace(/[:.]/g, '-')
+  for (let suffix = 0; suffix < 1000; suffix++) {
+    const path = join(target, `dsh-screenshot-${stamp}${suffix ? '-' + suffix : ''}.png`)
+    try {
+      await writeFile(path, png, { flag: 'wx' })
+      return path
+    } catch (error) {
+      if (error?.code !== 'EEXIST') throw error
+    }
+  }
+  throw new Error('could not choose a unique screenshot filename')
+}

package/lib/splash-opencode.js

@@ -1,10 +1,11 @@
 // OpenCode-style splash screen: the DeepSeek brand mark with input hints
 import { t as tr } from './i18n.js'
-import { displayWidth } from './util.js'
+import { displayWidth, shortenPath, truncateWidth } from './util.js'
 
 // The DeepSeek mark as it has always been drawn on the title screen: the
 // name in a blue→white gradient, set as one line rather than ASCII art.
 const BRAND = 'DeepSeek Harness'
+const BRAND_BLUE = '#4d6bfe'
 const BRAND_TAIL = '#ffffff'
 
 // Color mixing helper (linear interpolation in RGB space)
@@ -27,26 +28,21 @@ function mixColor(a, b, t) {
 
 /**
  * Paint the OpenCode-style splash screen:
- * - DeepSeek brand mark centered vertically and horizontally
- * - Workspace/git info and model below the mark
- * - Input prompt below
- * - Keyboard shortcuts at bottom
+ * - DeepSeek brand mark above the centered composer
+ * - Keyboard shortcuts and workspace/git context below it
  *
  * @param {Screen} screen - The screen buffer to paint to
  * @param {number} cols - Terminal columns
  * @param {number} rows - Terminal rows
  * @param {object} theme - Color theme
  * @param {object} ctx - Context: { workingDirectory, gitBranch, model, provider }
- * @param {number} floor - Last row the splash may use (the composer claims the rest)
- * @param {object} area - Horizontal band the splash centers in: { x0, width }.
- *   Defaults to the full screen; the status rail passes the main area's band so
- *   the brand never centers under the rail.
+ * @param {number} floor - Shortcut row for a standalone splash
+ * @param {object} area - Composer band: { x0, width, composerTop, composerBottom }.
  */
 export function paintSplashOpenCode(screen, cols, rows, theme, ctx = {}, floor = rows - 1, area = {}) {
   const chars = Array.from(BRAND)
 
-  // Center the brand vertically (slightly above center for better balance)
-  const brandRow = Math.max(0, Math.floor((rows - 1) / 2) - 3)
+  const brandRow = Math.max(1, (area.composerTop ?? Math.floor((rows - 1) / 2)) - 3)
 
   // The horizontal band: bounded by the caller, centered content within it.
   const x0 = Math.max(0, Math.min(area.x0 ?? 0, cols - 1))
@@ -60,49 +56,56 @@ export function paintSplashOpenCode(screen, cols, rows, theme, ctx = {}, floor =
   const brandX = centerX(BRAND)
   for (let i = 0; i < chars.length; i++) {
     const t = chars.length > 1 ? i / (chars.length - 1) : 0
-    screen.text(brandX + i, brandRow, chars[i], { fg: mixColor(theme.primary, BRAND_TAIL, t), bold: true, bg: theme.background })
+    screen.text(brandX + i, brandRow, chars[i], { fg: mixColor(BRAND_BLUE, BRAND_TAIL, t), bold: true, bg: theme.background })
   }
 
-  // The shortcut row anchors to the bottom of the usable area; everything
-  // above it stacks out of the brand and has to stop short of that row.
-  const shortcutsY = Math.min(rows - 2, floor)
+  // Keep shortcuts close to the input while reserving the last status row.
+  const shortcutsY = Math.min(rows - 2, area.composerBottom != null ? area.composerBottom + 2 : floor)
 
   // Workspace/git/model info below the mark
-  let infoY = brandRow + 2
+  let infoY = area.composerBottom != null ? shortcutsY + 2 : brandRow + 2
   const { workingDirectory = '', gitBranch = '', model = '', provider = '' } = ctx
 
-  if (workingDirectory && infoY < shortcutsY - 2) {
-    const info = `${workingDirectory}${gitBranch ? `  git: ${gitBranch}` : ''}`
-    screen.text(centerX(info), infoY, info, { fg: theme.textMuted, bg: theme.background })
+  if (workingDirectory && infoY < rows - 2) {
+    const branch = gitBranch ? '  git: ' + truncateWidth(gitBranch, Math.max(4, Math.floor(bandW / 3))) : ''
+    const info = shortenPath(workingDirectory, Math.max(4, bandW - displayWidth(branch))) + branch
+    screen.text(centerX(info), infoY, truncateWidth(info, bandW), { fg: theme.textMuted, bg: theme.background })
     infoY++
   }
 
-  if (model && infoY < shortcutsY - 1) {
+  if (area.composerTop == null && model && infoY < shortcutsY - 1) {
     const modelInfo = provider ? `${provider}/${model}` : model
-    screen.text(centerX(modelInfo), infoY, modelInfo, { fg: theme.secondary, bg: theme.background })
+    screen.text(centerX(modelInfo), infoY, truncateWidth(modelInfo, bandW), { fg: theme.secondary, bg: theme.background })
     infoY++
   }
 
   // Input hint below info
   const hintY = infoY + 1
-  if (hintY < shortcutsY) {
+  if (area.composerTop == null && hintY < shortcutsY) {
     const hint = tr('splash.hint')
-    screen.text(centerX(hint), hintY, hint, { fg: theme.textMuted, bg: theme.background })
+    screen.text(centerX(hint), hintY, truncateWidth(hint, bandW), { fg: theme.textMuted, bg: theme.background })
   }
 
   // Keyboard shortcuts at bottom: only affordances that actually exist on the
   // title screen. A narrow terminal drops whole groups rather than cutting any
-  // group in half; settings is the more valuable of the two, and the branch
-  // switcher the least, so the drop order is thinking then branches. Each
+  // group in half; settings and thinking take priority over branches. Each
   // group paints its key in the accent color and bold so the key reads apart
   // from the muted description that follows it.
-  if (shortcutsY > hintY + 2) {
+  if (shortcutsY > brandRow + 2) {
     const sep = '    '
     const pairs = [
       ['Ctrl+P', tr('splash.shortcutSettings')],
       ['Tab', tr('splash.shortcutThinking')],
       ['Ctrl+G', tr('splash.shortcutBranches')],
+      ['Ctrl+S', tr('screenshot.shortcut')],
     ]
+    const essentialWidth = pairs.slice(0, 2).reduce((n, [key, desc]) => n + displayWidth(key) + 2 + displayWidth(desc), displayWidth(sep))
+    if (essentialWidth > bandW - 2) {
+      const descBudget = Math.max(0, bandW - 2 - displayWidth('Ctrl+P  Tab') - displayWidth(sep) - 2)
+      const firstRoom = Math.min(displayWidth(pairs[0][1]), Math.floor(descBudget / 2))
+      pairs[0][1] = truncateWidth(pairs[0][1], firstRoom)
+      pairs[1][1] = truncateWidth(pairs[1][1], descBudget - firstRoom)
+    }
     const kept = []
     let width = 0
     for (const [key, desc] of pairs) {

package/lib/startup.js

@@ -1,48 +1,66 @@
-// The TUI app's command-line provider: parses the dsh --profile tui flag
-// family (--resume, --model, --provider, --sidebar) and its --help text, then
-// provides the immutable values as the tuiStartup service. Ordinary rows
-// inject that service and read it as a lazily-resolved value.
-import { Command } from 'commander'
-import { parseCmdline } from '@deepseek-ai/dsh-cmdline'
-import { resolveLocale, setLocale, t } from './i18n.js'
-
-export const name = 'dsh-oc-tui/startup'
-export const inject = ['cmdlineArgs']
-export const TUI_STARTUP_SERVICE = 'tuiStartup'
-
-// The command line is parsed before the plugin applies, so the settings file is
-// not readable here: the help text follows the environment (DSH_TUI_LOCALE, or
-// the OS language) and the boot itself then re-resolves the stored preference.
-try { setLocale(resolveLocale('system')) } catch { /* the help falls back to English */ }
-
-function tuiCommand() {
-  return new Command()
-    .name('dsh --profile tui')
-    .description(t('startup.description'))
-    .helpOption('-h, --help', t('startup.helpOption'))
-    .option('--resume <sessionId>', t('startup.resume'))
-    .option('--model <modelId>', t('startup.model'))
-    .option('--provider <provider>', t('startup.provider'))
-    .option('--sidebar', t('startup.sidebar'))
-    .option('--no-sidebar', t('startup.noSidebar'))
-    .addHelpText('after', `
-${t('startup.examples')}
-  dsh --profile tui                      ${t('startup.exampleFresh')}
-  dsh --profile tui --resume abc123      ${t('startup.exampleResume')}
-  dsh --profile tui --model deepseek-v4-flash
-`)
-}
-
-export function apply(ctx) {
-  const program = tuiCommand()
-  program.action(() => {
-    const options = program.opts()
-    ctx.provide(TUI_STARTUP_SERVICE, {
-      resume: options.resume ?? null,
-      model: options.model ?? null,
-      provider: options.provider ?? null,
-      sidebar: options.sidebar !== false,
-    })
-  })
-  parseCmdline(ctx, program)
-}
+// The TUI app's command-line provider: parses the dsh --profile tui flag
+// family (--resume, --model, --provider, --sidebar) and its --help text, then
+// provides the immutable values as the tuiStartup service. Ordinary rows
+// inject that service and read it as a lazily-resolved value.
+import { Command } from 'commander'
+import { parseCmdline } from '@deepseek-ai/dsh-cmdline'
+import { resolveLocale, setLocale, t } from './i18n.js'
+import { createMcpMonitor, createMcpNotifier, filterMcpStderrWrites, isolateMcpOutput } from './mcp-monitor.js'
+
+export const name = 'dsh-oc-tui/startup'
+export const inject = ['cmdlineArgs']
+export const TUI_STARTUP_SERVICE = 'tuiStartup'
+
+// The command line is parsed before the plugin applies, so the settings file is
+// not readable here: the help text follows the environment (DSH_TUI_LOCALE, or
+// the OS language) and the boot itself then re-resolves the stored preference.
+try { setLocale(resolveLocale('system')) } catch { /* the help falls back to English */ }
+
+function tuiCommand() {
+  return new Command()
+    .name('dsh --profile tui')
+    .description(t('startup.description'))
+    .helpOption('-h, --help', t('startup.helpOption'))
+    .option('--resume <sessionId>', t('startup.resume'))
+    .option('--model <modelId>', t('startup.model'))
+    .option('--provider <provider>', t('startup.provider'))
+    .option('--sidebar', t('startup.sidebar'))
+    .option('--no-sidebar', t('startup.noSidebar'))
+    .addHelpText('after', `
+${t('startup.examples')}
+  dsh --profile tui                      ${t('startup.exampleFresh')}
+  dsh --profile tui --resume abc123      ${t('startup.exampleResume')}
+  dsh --profile tui --model deepseek-v4-flash
+`)
+}
+
+export function apply(ctx) {
+  // An MCP server that cannot be reached must not write to the terminal: the
+  // host's client reports the failure there, and a stdio server inherits the
+  // terminal's stderr. The isolation goes in before the app mounts, so the
+  // output is gone before anything can paint over the frame. The state is
+  // watched from here too — the host's MCP rows are mounted next.
+  const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY)
+  const restoreOutput = interactive ? isolateMcpOutput() : null
+  const restoreStderr = interactive ? filterMcpStderrWrites() : null
+  const mcpMonitor = interactive ? createMcpMonitor(ctx) : null
+  const mcpNotifier = createMcpNotifier()
+  ctx.effect(() => () => {
+    mcpMonitor?.detach()
+    restoreStderr?.()
+    restoreOutput?.()
+  })
+  const program = tuiCommand()
+  program.action(() => {
+    const options = program.opts()
+    ctx.provide(TUI_STARTUP_SERVICE, {
+      resume: options.resume ?? null,
+      model: options.model ?? null,
+      provider: options.provider ?? null,
+      sidebar: options.sidebar !== false,
+      mcpMonitor,
+      mcpNotifier,
+    })
+  })
+  parseCmdline(ctx, program)
+}

package/lib/term.js

@@ -33,15 +33,27 @@ export function makeStyle(partial = {}) {
   }
 }
 
+// Stand-in for an absent style layer in mergeStyle(). Frozen because styles
+// are treated as immutable everywhere else; nothing may write through it.
+const EMPTY_STYLE = Object.freeze(makeStyle({}))
+
+// A segment's `style` is null until something paints it — markdown emits the
+// indent pads of a wrapped list item and the bare prefix pads that way — so
+// both layers are legitimately absent. Reading a missing layer as "sets no
+// properties" keeps `mergeStyle(seg.style, tint)` total: tinting a
+// null-styled segment is the first thing a collapsed thinking/note body does
+// when the reader expands it.
 export function mergeStyle(base, over) {
+  const b = base ?? EMPTY_STYLE
+  const o = over ?? EMPTY_STYLE
   return {
-    fg: over.fg ?? base.fg ?? null,
-    bg: over.bg ?? base.bg ?? null,
-    bold: over.bold ?? base.bold ?? false,
-    dim: over.dim ?? base.dim ?? false,
-    italic: over.italic ?? base.italic ?? false,
-    underline: over.underline ?? base.underline ?? false,
-    link: over.link ?? base.link,
+    fg: o.fg ?? b.fg ?? null,
+    bg: o.bg ?? b.bg ?? null,
+    bold: o.bold ?? b.bold ?? false,
+    dim: o.dim ?? b.dim ?? false,
+    italic: o.italic ?? b.italic ?? false,
+    underline: o.underline ?? b.underline ?? false,
+    link: o.link ?? b.link,
   }
 }
 
@@ -226,6 +238,19 @@ function csiModifierFlags(param) {
   return { shift: (bits & 1) !== 0, alt: (bits & 2) !== 0, ctrl: (bits & 4) !== 0 }
 }
 
+// Enter with modifiers, carrying only the flags that are actually set: an
+// absent flag means "not pressed", which is what the composer's newline check
+// tests. Both CSI-u and modifyOtherKeys encode the modifier as 1 + bitmask
+// (shift 1, alt 2, ctrl 4, meta 8).
+function enterKey(modifier) {
+  const bits = Math.max(0, (Number(modifier) || 1) - 1)
+  const key = { name: 'enter' }
+  if (bits & 1) key.shift = true
+  if (bits & 2) key.alt = true
+  if (bits & 4) key.ctrl = true
+  return key
+}
+
 // Decode one key event from a raw-mode byte buffer. Returns { key } or null
 // when more bytes are needed.
 export function decodeKey(input) {
@@ -365,13 +390,27 @@ export function decodeKey(input) {
       if (final === 'F') return { key: { name: 'end' }, consumed }
       if (final === 'Z') return { key: { name: 'shift-tab' }, consumed }
       if (final === 'u') {
+        // CSI-u spells the key out by codepoint, so Enter stops being a bare
+        // CR and Ctrl+Enter becomes distinguishable from Enter. This is the
+        // shape the newline binding depends on: without it a terminal that
+        // cannot disambiguate sends the same byte for both.
         const [code, modifier = 1] = param.split(';').map(Number)
-        if (code === 13 && (modifier === 2 || modifier === 3)) return { key: { name: 'enter', shift: true }, consumed }
-        if (code === 13 && modifier === 5) return { key: { name: 'enter', ctrl: true }, consumed }
+        if (code === 13) return { key: enterKey(modifier), consumed }
         if (code > 0 && modifier === 5) return { key: { name: String.fromCodePoint(code), ctrl: true }, consumed }
       }
       if (final === '~') {
         const p = Number(param)
+        // xterm modifyOtherKeys level 2 (CSI > 4 ; 2 m) is the other spelling
+        // of the same idea: CSI 27 ; <mod> ; <code> ~. It arrives here rather
+        // than at 'u' on terminals without CSI-u support.
+        const mok = /^27;(\d+);(\d+)$/.exec(param)
+        if (mok) {
+          const modifier = Number(mok[1])
+          const code = Number(mok[2])
+          if (code === 13) return { key: enterKey(modifier), consumed }
+          if (code > 0 && modifier === 5) return { key: { name: String.fromCodePoint(code), ctrl: true }, consumed }
+          return { key: { name: 'unknown', sequence: s.slice(0, consumed) }, consumed }
+        }
         const map = { 2: 'insert', 3: 'delete', 5: 'pageup', 6: 'pagedown', 7: 'home', 8: 'end' }
         if (map[p]) return { key: { name: map[p] }, consumed }
         if (p >= 11 && p <= 15) return { key: { name: 'f' + (p - 10) }, consumed }
@@ -397,8 +436,11 @@ export function decodeKey(input) {
   const ch = Buffer.from([first]).toString('latin1')
   if (first === 0x1b) return { key: { name: 'escape' }, consumed: 1 }
   if (first === 0x0a) {
-    // LF = Ctrl+J / Ctrl+Enter in raw mode. Route it to the newline path so
-    // Ctrl+Enter inserts a line break instead of submitting (Enter is CR).
+    // LF is what a terminal that cannot disambiguate sends for Ctrl+Enter, so
+    // it routes to the newline path instead of submitting (plain Enter is CR).
+    // Ctrl+J is the same byte by definition — it *is* a line feed — so this
+    // path cannot separate the two; only CSI-u / modifyOtherKeys can, and the
+    // ones that do arrive as `enter` with a ctrl flag above.
     return { key: { name: 'enter', ctrl: true }, consumed: 1 }
   }
   if (first < 0x20 || first === 0x7f) {

package/lib/themes.js

@@ -0,0 +1,101 @@
+// The palette keys are shared by chrome, transcript, markdown, and diagrams.
+export const DEFAULT_THEME = 'deepseek'
+
+export const THEME_IDS = ['deepseek', 'github-dark', 'dracula', 'vscode-dark', 'nord']
+
+const deepseek = {
+  primary: '4d6bfe', secondary: '6c9cff', accent: '7c9cff',
+  error: 'e06c75', warning: 'e8c468', success: '7fd88f', info: '56b6c2',
+  text: 'f0f4ff', textMuted: 'a0aac0',
+  background: '0a0e18', backgroundPanel: '111a2c', backgroundElement: '1b2740',
+  border: '3d4d73', borderSubtle: '2b3a5c',
+  markdownHeading: '7c9cff', markdownLinkText: '6c9cff', markdownCode: '7fd88f',
+  markdownCodeBlock: 'f0f4ff', markdownBlockQuote: '9fb0d8',
+  markdownListItem: '4d6bfe', markdownHorizontalRule: '46547a', codeBg: '111a2c',
+  thinking: '9aa6c2', reminder: 'c5bdf7', imageChipBg: 'd97706', imageChipText: '1a0d00',
+  compaction: '95d8c0', inbox: '9fd0e8', steering: '9fd0e8', systemPrompt: 'b9c4dd',
+  contextSystem: '7fd88f', contextTools: 'e8c468', contextMessages: '56b6c2',
+  selection: '3153b8',
+  syntaxKeyword: 'c792ea', syntaxString: '9ece8f', syntaxNumber: 'e5b567',
+  syntaxComment: '8994b0', syntaxFunction: '82aaff', syntaxType: 'e5c07b',
+  tableBorder: '41528a', userPointer: '4d6bfe', assistantLabel: '9aa6c2',
+}
+
+const palettes = {
+  deepseek,
+  'github-dark': {
+    ...deepseek,
+    primary: '58a6ff', secondary: '79c0ff', accent: '79c0ff',
+    error: 'ff7b72', warning: 'e3b341', success: '3fb950', info: '58a6ff',
+    text: 'e6edf3', textMuted: 'a0aab5', background: '0d1117',
+    backgroundPanel: '161b22', backgroundElement: '21262d', border: '484f58', borderSubtle: '30363d',
+    markdownHeading: '79c0ff', markdownLinkText: '58a6ff', markdownCode: 'a5d6ff',
+    markdownCodeBlock: 'e6edf3', markdownBlockQuote: 'a0aab5', markdownListItem: '58a6ff',
+    markdownHorizontalRule: '484f58', codeBg: '161b22',
+    thinking: 'a0aab5', reminder: 'd2a8ff', compaction: '7ee787',
+    inbox: '79c0ff', steering: '79c0ff', systemPrompt: 'b1bac4',
+    contextSystem: '3fb950', contextTools: 'e3b341', contextMessages: '58a6ff',
+    selection: '264f78', syntaxKeyword: 'ff7b72', syntaxString: 'a5d6ff',
+    syntaxNumber: '79c0ff', syntaxComment: '8b949e', syntaxFunction: 'd2a8ff',
+    syntaxType: 'ffa657', tableBorder: '484f58', userPointer: '58a6ff', assistantLabel: 'a0aab5',
+  },
+  dracula: {
+    ...deepseek,
+    primary: 'bd93f9', secondary: '8be9fd', accent: 'bd93f9',
+    error: 'ff5555', warning: 'f1fa8c', success: '50fa7b', info: '8be9fd',
+    text: 'f8f8f2', textMuted: 'b0b4ca', background: '191a24',
+    backgroundPanel: '222430', backgroundElement: '2c2f3e', border: '6272a4', borderSubtle: '50566f',
+    markdownHeading: 'bd93f9', markdownLinkText: '8be9fd', markdownCode: '50fa7b',
+    markdownCodeBlock: 'f8f8f2', markdownBlockQuote: 'b0b4ca', markdownListItem: 'bd93f9',
+    markdownHorizontalRule: '6272a4', codeBg: '222430',
+    thinking: 'b0b4ca', reminder: 'ff79c6', compaction: '50fa7b',
+    inbox: '8be9fd', steering: '8be9fd', systemPrompt: 'c2c7df',
+    contextSystem: '50fa7b', contextTools: 'f1fa8c', contextMessages: '8be9fd',
+    selection: '333a50', syntaxKeyword: 'ff79c6', syntaxString: 'f1fa8c',
+    syntaxNumber: 'bd93f9', syntaxComment: '9ba7d0', syntaxFunction: '50fa7b',
+    syntaxType: '8be9fd', tableBorder: '6272a4', userPointer: 'bd93f9', assistantLabel: 'b0b4ca',
+  },
+  'vscode-dark': {
+    ...deepseek,
+    primary: '3794ff', secondary: '9cdcfe', accent: '4fc1ff',
+    error: 'f48771', warning: 'cca700', success: '89d185', info: '75beff',
+    text: 'd4d4d4', textMuted: 'a8a8a8', background: '1e1e1e',
+    backgroundPanel: '252526', backgroundElement: '333333', border: '555555', borderSubtle: '3c3c3c',
+    markdownHeading: '569cd6', markdownLinkText: '4fc1ff', markdownCode: 'ce9178',
+    markdownCodeBlock: 'd4d4d4', markdownBlockQuote: 'a8a8a8', markdownListItem: '3794ff',
+    markdownHorizontalRule: '555555', codeBg: '252526',
+    thinking: 'a8a8a8', reminder: 'c586c0', compaction: '89d185',
+    inbox: '9cdcfe', steering: '9cdcfe', systemPrompt: 'bcbcbc',
+    contextSystem: '89d185', contextTools: 'cca700', contextMessages: '75beff',
+    selection: '264f78', syntaxKeyword: 'c586c0', syntaxString: 'ce9178',
+    syntaxNumber: 'b5cea8', syntaxComment: '8aaa80', syntaxFunction: 'dcdcaa',
+    syntaxType: '4ec9b0', tableBorder: '555555', userPointer: '3794ff', assistantLabel: 'a8a8a8',
+  },
+  nord: {
+    ...deepseek,
+    primary: '88c0d0', secondary: '81a1c1', accent: '8fbcbb',
+    error: 'bf616a', warning: 'ebcb8b', success: 'a3be8c', info: '88c0d0',
+    text: 'eceff4', textMuted: 'b0bccd', background: '191f29',
+    backgroundPanel: '252c39', backgroundElement: '2b3443', border: '677994', borderSubtle: '4c566a',
+    markdownHeading: '88c0d0', markdownLinkText: '8fbcbb', markdownCode: 'a3be8c',
+    markdownCodeBlock: 'eceff4', markdownBlockQuote: 'b0bccd', markdownListItem: '88c0d0',
+    markdownHorizontalRule: '677994', codeBg: '252c39',
+    thinking: 'b0bccd', reminder: 'b48ead', compaction: 'a3be8c',
+    inbox: '88c0d0', steering: '88c0d0', systemPrompt: 'd8dee9',
+    contextSystem: 'a3be8c', contextTools: 'ebcb8b', contextMessages: '88c0d0',
+    selection: '344253', syntaxKeyword: '81a1c1', syntaxString: 'a3be8c',
+    syntaxNumber: 'b48ead', syntaxComment: 'a0afc3', syntaxFunction: '88c0d0',
+    syntaxType: '8fbcbb', tableBorder: '677994', userPointer: '88c0d0', assistantLabel: 'b0bccd',
+  },
+}
+
+for (const palette of Object.values(palettes)) Object.freeze(palette)
+export const THEME = palettes[DEFAULT_THEME]
+
+export function themeId(value) {
+  return typeof value === 'string' && Object.hasOwn(palettes, value) ? value : DEFAULT_THEME
+}
+
+export function getTheme(value) {
+  return palettes[themeId(value)]
+}