martty 0.2.11

package/lib/jsonrpc-line-transport.js

@@ -0,0 +1,155 @@
+/**
+ * Newline-delimited JSON-RPC 2.0 over caller-owned streams.
+ *
+ * Local copy of the wire the native TUI speaks. Published `dsh` does not put
+ * `@deepseek-ai/dsh-sdk-protocol` on the profile module fallback, and listing
+ * that package as an npm dependency makes `dsh plugin add` warn about its
+ * unmet peers (profile `autoInstallPeers: false`).
+ */
+
+import { StringDecoder } from 'node:string_decoder'
+
+export class JsonRpcLineTransport {
+  constructor(input, output) {
+    this.input = input
+    this.output = output
+    this.buffer = ''
+    this.decoder = new StringDecoder('utf8')
+    this.started = false
+    this.requestHandler = undefined
+    this.notificationHandler = undefined
+    this.pending = new Map()
+  }
+
+  start() {
+    if (this.started) return
+    this.started = true
+    this.input.on('data', this.onData)
+    this.input.on('error', this.onInputError)
+    this.input.on('end', this.onInputEnd)
+  }
+
+  close() {
+    this.input.off('data', this.onData)
+    this.input.off('error', this.onInputError)
+    this.input.off('end', this.onInputEnd)
+    this.failPending(new Error('JSON-RPC transport closed'))
+  }
+
+  onRequest(handler) {
+    this.requestHandler = handler
+  }
+
+  onNotification(handler) {
+    this.notificationHandler = handler
+  }
+
+  notify(method, params) {
+    this.write(
+      params === undefined
+        ? { jsonrpc: '2.0', method }
+        : { jsonrpc: '2.0', method, params },
+    )
+  }
+
+  flush() {
+    return new Promise((resolve, reject) => {
+      this.output.write('', (error) => {
+        if (error) reject(error)
+        else resolve()
+      })
+    })
+  }
+
+  onData = (chunk) => {
+    this.buffer += typeof chunk === 'string' ? chunk : this.decoder.write(chunk)
+    this.drainLines()
+  }
+
+  drainLines() {
+    for (;;) {
+      const newline = this.buffer.indexOf('\n')
+      if (newline < 0) break
+      const line = this.buffer.slice(0, newline).trim()
+      this.buffer = this.buffer.slice(newline + 1)
+      if (!line) continue
+      void this.handleLine(line)
+    }
+  }
+
+  onInputError = (error) => {
+    this.failPending(error)
+  }
+
+  onInputEnd = () => {
+    this.buffer += this.decoder.end()
+    this.drainLines()
+    this.failPending(new Error('JSON-RPC input closed'))
+  }
+
+  async handleLine(line) {
+    let message
+    try {
+      message = JSON.parse(line)
+    } catch {
+      return
+    }
+    if (!message || typeof message !== 'object') return
+    const id = message.id
+    const method = message.method
+    if ((typeof id === 'string' || typeof id === 'number') && typeof method === 'string') {
+      await this.handleIncomingRequest(id, method, objectParams(message.params))
+      return
+    }
+    if (typeof id === 'string' || typeof id === 'number') {
+      this.handleIncomingResponse(id, message)
+      return
+    }
+    if (typeof method === 'string') {
+      this.notificationHandler?.(method, objectParams(message.params))
+    }
+  }
+
+  async handleIncomingRequest(id, method, params) {
+    const handler = this.requestHandler
+    if (!handler) {
+      this.write({ jsonrpc: '2.0', id, error: { code: -32601, message: `method not found: ${method}` } })
+      return
+    }
+    try {
+      const result = await handler(method, params)
+      this.write({ jsonrpc: '2.0', id, result })
+    } catch (error) {
+      this.write({
+        jsonrpc: '2.0',
+        id,
+        error: { code: -32603, message: error instanceof Error ? error.message : String(error) },
+      })
+    }
+  }
+
+  handleIncomingResponse(id, frame) {
+    const pending = this.pending.get(id)
+    if (!pending) return
+    this.pending.delete(id)
+    if (frame.error && typeof frame.error === 'object') {
+      pending.reject(new Error(typeof frame.error.message === 'string' ? frame.error.message : 'JSON-RPC error'))
+      return
+    }
+    pending.resolve(frame.result)
+  }
+
+  write(message) {
+    this.output.write(`${JSON.stringify(message)}\n`)
+  }
+
+  failPending(error) {
+    const pending = [...this.pending.values()]
+    this.pending.clear()
+    for (const waiter of pending) waiter.reject(error)
+  }
+}
+
+function objectParams(params) {
+  return params && typeof params === 'object' && !Array.isArray(params) ? params : {}
+}

package/lib/mux.js

@@ -0,0 +1,281 @@
+/**
+ * Byte mux between an ACP agent and the Rust ACP client.
+ *
+ * spawn-tui connection: `output` is Node→TUI (Rust reads fd 3), `input` is
+ * TUI→Node (Rust writes fd 4). Agent stdout feeds `output` except Client-plane
+ * Cordis Client-plane extensions; Rust outgoing on `input` goes
+ * to agent stdin except compositor paint methods. Palette notifications are
+ * injected toward Rust only. Node-originated JSON-RPC ids stay
+ * off the painter.
+ */
+
+import { CORDIS_CAPABILITY, CORDIS_METHODS, readCordisCapability } from './cordis-protocol.js'
+
+const COMPOSITOR_METHODS = Object.freeze(new Set([
+  CORDIS_METHODS.themeUpdate,
+  CORDIS_METHODS.themeRemove,
+  CORDIS_METHODS.themeSelected,
+  CORDIS_METHODS.slotsUpdate,
+  CORDIS_METHODS.commandsUpdate,
+  CORDIS_METHODS.overlayUpdate,
+  CORDIS_METHODS.commandInvoke,
+  CORDIS_METHODS.overlayEvent,
+  CORDIS_METHODS.sessionConfigSet,
+]))
+
+/** Agent → TUI Node extras. Not compositor paint; Rust never sees these. */
+export const HOST_METHODS = Object.freeze(new Set([
+  CORDIS_METHODS.inspectQuery,
+  CORDIS_METHODS.inspectQueryResolved,
+  CORDIS_METHODS.requestRun,
+  CORDIS_METHODS.requestRunResolved,
+  CORDIS_METHODS.userRun,
+  CORDIS_METHODS.pluginRetract,
+]))
+
+/**
+ * @param {{ jsonrpc?: unknown, method?: unknown, id?: unknown }} message
+ * @returns {boolean}
+ */
+export function isCompositorMessage(message) {
+  return typeof message.method === 'string' && COMPOSITOR_METHODS.has(message.method)
+}
+
+/**
+ * @param {{ jsonrpc?: unknown, method?: unknown }} message
+ * @returns {boolean}
+ */
+export function isHostMessage(message) {
+  return typeof message.method === 'string' && HOST_METHODS.has(message.method)
+}
+
+/**
+ * Stamp `clientCapabilities._meta.dsh.cordis` so dsh-acp forwards Client jobs.
+ * Zed never sets this; unknown agents ignore the extra field.
+ * @param {object} message
+ * @returns {object}
+ */
+export function advertiseCordis(message) {
+  if (message.method !== 'initialize') return message
+  const params = message.params !== null && typeof message.params === 'object' && !Array.isArray(message.params)
+    ? { ...message.params }
+    : {}
+  const caps = params.clientCapabilities !== null && typeof params.clientCapabilities === 'object'
+    && !Array.isArray(params.clientCapabilities)
+    ? { ...params.clientCapabilities }
+    : {}
+  const meta = caps._meta !== null && typeof caps._meta === 'object' && !Array.isArray(caps._meta)
+    ? { ...caps._meta }
+    : {}
+  const dsh = meta.dsh !== null && typeof meta.dsh === 'object' && !Array.isArray(meta.dsh)
+    ? { ...meta.dsh }
+    : {}
+  dsh.cordis = { ...CORDIS_CAPABILITY }
+  meta.dsh = dsh
+  delete meta.tuiInspect
+  caps._meta = meta
+  params.clientCapabilities = caps
+  return { ...message, params }
+}
+
+/**
+ * @param {import('node:stream').Writable} dest
+ * @param {unknown} value
+ */
+export function writeJsonLine(dest, value) {
+  dest.write(`${JSON.stringify(value)}\n`)
+}
+
+/**
+ * Pipe NDJSON, invoking `onLine` for each complete line (trimmed, non-empty).
+ * @param {import('node:stream').Readable} source
+ * @param {(line: string) => void} onLine
+ */
+export function onJsonLines(source, onLine) {
+  let buffer = ''
+  source.on('data', (chunk) => {
+    buffer += chunk.toString('utf8')
+    for (;;) {
+      const newline = buffer.indexOf('\n')
+      if (newline < 0) break
+      const line = buffer.slice(0, newline).trim()
+      buffer = buffer.slice(newline + 1)
+      if (line.length === 0) continue
+      onLine(line)
+    }
+  })
+}
+
+/**
+ * @param {{
+ *   agent: { stdin: import('node:stream').Writable, stdout: import('node:stream').Readable },
+ *   tui: { input: import('node:stream').Writable, output: import('node:stream').Readable },
+ *   onCompositor?: (message: object) => unknown | Promise<unknown>,
+ *   onHost?: (message: object) => void,
+ *   onCordisReady?: (capability: { protocol: number }) => void,
+ *   onAcp?: (direction: 'client' | 'agent', message: object) => void,
+ * }} opts
+ * @returns {{
+ *   notifyTui: (method: string, params?: object) => void,
+ *   requestAgent: (method: string, params?: object) => Promise<unknown>,
+ *   requestTui: (method: string, params?: object) => Promise<unknown>,
+ * }}
+ */
+export function muxAcpAndCompositor(opts) {
+  const { agent, tui, onCompositor, onHost, onCordisReady, onAcp } = opts
+  for (const stream of [agent.stdin, agent.stdout, tui.input, tui.output]) {
+    stream.on?.('error', () => {})
+  }
+
+  /** @type {Map<string, { resolve: (value: unknown) => void, reject: (error: Error) => void }>} */
+  const pendingAgent = new Map()
+  const pendingTui = new Map()
+  let nextHostId = 0
+  let nextTuiId = 0
+  /** @type {unknown} */
+  let initializeId
+  /** @type {{ protocol: number } | null} */
+  let agentCordis = null
+
+  onJsonLines(agent.stdout, (line) => {
+    let message
+    try {
+      message = JSON.parse(line)
+    } catch {
+      tui.output.write(`${line}\n`)
+      return
+    }
+    if (message && typeof message === 'object' && pendingAgent.has(message.id)) {
+      const waiter = pendingAgent.get(message.id)
+      pendingAgent.delete(message.id)
+      if (message.error !== undefined) {
+        const detail = message.error && typeof message.error === 'object' ? message.error.message : undefined
+        waiter.reject(new Error(typeof detail === 'string' ? detail : 'ACP extension request failed'))
+      } else {
+        waiter.resolve(message.result)
+      }
+      return
+    }
+    if (isHostMessage(message)) {
+      if (agentCordis !== null) onHost?.(message)
+      return
+    }
+    onAcp?.('agent', message)
+    tui.output.write(`${line}\n`)
+    if (initializeId !== undefined && message && typeof message === 'object' && message.id === initializeId) {
+      initializeId = undefined
+      agentCordis = readCordisCapability(message.result)
+      if (agentCordis !== null) onCordisReady?.(agentCordis)
+    }
+  })
+
+  onJsonLines(tui.input, (line) => {
+    let message
+    try {
+      message = JSON.parse(line)
+    } catch {
+      agent.stdin.write(`${line}\n`)
+      return
+    }
+    if (message && typeof message === 'object' && pendingTui.has(message.id)) {
+      const waiter = pendingTui.get(message.id)
+      pendingTui.delete(message.id)
+      if (message.error !== undefined) {
+        const detail = message.error && typeof message.error === 'object' ? message.error.message : undefined
+        waiter.reject(new Error(typeof detail === 'string' ? detail : 'TUI compositor request failed'))
+      } else {
+        waiter.resolve(message.result)
+      }
+      return
+    }
+    if (isCompositorMessage(message)) {
+      const hasId = message.id !== undefined
+      if (onCompositor === undefined) {
+        if (hasId) {
+          writeJsonLine(tui.output, {
+            jsonrpc: '2.0',
+            id: message.id,
+            error: { code: -32601, message: 'Method not found' },
+          })
+        }
+        return
+      }
+      Promise.resolve()
+        .then(() => onCompositor(message))
+        .then((result) => {
+          if (hasId) writeJsonLine(tui.output, { jsonrpc: '2.0', id: message.id, result: result ?? null })
+        })
+        .catch((error) => {
+          if (!hasId) return
+          writeJsonLine(tui.output, {
+            jsonrpc: '2.0',
+            id: message.id,
+            error: {
+              code: -32000,
+              message: error instanceof Error ? error.message : String(error),
+            },
+          })
+        })
+      return
+    }
+    if (
+      typeof message.method === 'string'
+      && message.method.startsWith('_dsh/cordis/')
+      && agentCordis === null
+    ) {
+      if (message.id !== undefined) {
+        writeJsonLine(tui.output, {
+          jsonrpc: '2.0',
+          id: message.id,
+          error: { code: -32601, message: 'agent has not advertised _dsh/cordis' },
+        })
+      }
+      return
+    }
+    const outgoing = advertiseCordis(message)
+    if (outgoing.method === 'initialize' && outgoing.id !== undefined) {
+      initializeId = outgoing.id
+    }
+    onAcp?.('client', outgoing)
+    writeJsonLine(agent.stdin, outgoing)
+  })
+
+  return {
+    notifyTui(method, params) {
+      writeJsonLine(
+        tui.output,
+        params === undefined ? { jsonrpc: '2.0', method } : { jsonrpc: '2.0', method, params },
+      )
+    },
+    requestAgent(method, params) {
+      if (method.startsWith('_dsh/cordis/') && agentCordis === null) {
+        return Promise.reject(new Error('agent has not advertised _dsh/cordis'))
+      }
+      const id = `tui-host-${++nextHostId}`
+      return new Promise((resolve, reject) => {
+        pendingAgent.set(id, { resolve, reject })
+        writeJsonLine(
+          agent.stdin,
+          params === undefined
+            ? { jsonrpc: '2.0', id, method }
+            : { jsonrpc: '2.0', id, method, params },
+        )
+      })
+    },
+    requestTui(method, params) {
+      if (typeof method !== 'string' || !method.startsWith('_dsh/cordis/tui/')) {
+        return Promise.reject(new Error('requestTui only accepts _dsh/cordis/tui/* methods'))
+      }
+      const id = `tui-client-${++nextTuiId}`
+      return new Promise((resolve, reject) => {
+        pendingTui.set(id, { resolve, reject })
+        writeJsonLine(
+          tui.output,
+          params === undefined
+            ? { jsonrpc: '2.0', id, method }
+            : { jsonrpc: '2.0', id, method, params },
+        )
+      })
+    },
+  }
+}

package/lib/palettes/default.json

@@ -0,0 +1,44 @@
+{
+  "id": "default",
+  "label": "Default",
+  "dark": {
+    "bg": "#0F1115",
+    "surface": "#151517",
+    "panel": "#1B1B1C",
+    "fg": "#F9FAFB",
+    "fg_secondary": "#CFD3D6",
+    "fg_tertiary": "#979DA6",
+    "caption": "#81858C",
+    "brand": "#5686FE",
+    "brand_soft": "#679EFE",
+    "bubble_bg": "#1B1B1C",
+    "bubble_fg": "#F1F3F5",
+    "border": "#2C2C2E",
+    "code_bg": "#151517",
+    "ok": "#4ED17E",
+    "warn": "#F7AD31",
+    "err": "#F25A5A",
+    "hint": "#6C7A96",
+    "chip_bg": "#2C2C2E"
+  },
+  "light": {
+    "bg": "#FFFFFF",
+    "surface": "#F9FAFB",
+    "panel": "#F5F6F7",
+    "fg": "#0F1115",
+    "fg_secondary": "#43454A",
+    "fg_tertiary": "#61666B",
+    "caption": "#ADB2B8",
+    "brand": "#4176E6",
+    "brand_soft": "#5686FE",
+    "bubble_bg": "#F1F3F5",
+    "bubble_fg": "#0F1115",
+    "border": "#E1E5EE",
+    "code_bg": "#F5F6F7",
+    "ok": "#22C55E",
+    "warn": "#DD8629",
+    "err": "#EC1313",
+    "hint": "#546078",
+    "chip_bg": "#EBEEF2"
+  }
+}

package/lib/palettes/ember.json

@@ -0,0 +1,44 @@
+{
+  "id": "ember",
+  "label": "Ember",
+  "dark": {
+    "bg": "#16100E",
+    "surface": "#201612",
+    "panel": "#2A1C16",
+    "fg": "#FFF4E6",
+    "fg_secondary": "#D2B4A0",
+    "fg_tertiary": "#A0826E",
+    "caption": "#78645A",
+    "brand": "#F78C3C",
+    "brand_soft": "#FFAA5A",
+    "bubble_bg": "#30201A",
+    "bubble_fg": "#FFF4E6",
+    "border": "#463028",
+    "code_bg": "#1C1210",
+    "ok": "#78BE6E",
+    "warn": "#F7AD31",
+    "err": "#F25A5A",
+    "hint": "#C48C64",
+    "chip_bg": "#463028"
+  },
+  "light": {
+    "bg": "#FFF6EE",
+    "surface": "#FFE8D6",
+    "panel": "#FFDCC4",
+    "fg": "#2A1810",
+    "fg_secondary": "#5A3C2E",
+    "fg_tertiary": "#7A5848",
+    "caption": "#9A7868",
+    "brand": "#D96A1E",
+    "brand_soft": "#E88838",
+    "bubble_bg": "#FFE0C8",
+    "bubble_fg": "#2A1810",
+    "border": "#E8C4A8",
+    "code_bg": "#FFE8D6",
+    "ok": "#2F8F44",
+    "warn": "#DD8629",
+    "err": "#EC1313",
+    "hint": "#A06038",
+    "chip_bg": "#FFD4B0"
+  }
+}

package/lib/plan-view.js

@@ -0,0 +1,92 @@
+/** Built-in Client Plugin: ACP Plan dock plus a `/plan-view` fallback modal. */
+
+export const name = 'plan-view'
+export const inject = ['acpSessionPlan', 'tuiSlots', 'tuiCommands', 'tuiOverlay']
+
+export function apply(ctx) {
+  let current = ctx.acpSessionPlan.current()
+  let panel
+
+  const stopSlot = ctx.tuiSlots.inject('conversation.input.dock', () => {
+    panel = ctx.tuiSlots.register(
+      { name: 'conversation.input.dock', id: 'plan-view' },
+      dockNodes(current),
+    )
+    return () => panel.dispose()
+  })
+  const stopPlan = ctx.acpSessionPlan.subscribe((snapshot) => {
+    current = snapshot.plans.at(-1) ?? null
+    panel?.update(dockNodes(current))
+  })
+  const stopCommand = ctx.tuiCommands.register({
+    name: 'plan-view',
+    description: 'Open the current ACP plan',
+  }, async () => {
+    current = ctx.acpSessionPlan.current()
+    ctx.tuiOverlay.openView({
+      id: 'plan-view',
+      title: 'Plan',
+      nodes: viewNodes(current),
+    })
+  })
+
+  return () => {
+    stopCommand?.()
+    stopPlan?.()
+    stopSlot?.()
+  }
+}
+
+function dockNodes(plan) {
+  if (plan === null) return []
+  if (plan.kind === 'items') {
+    const total = plan.entries.length
+    if (total === 0) return []
+    const completed = plan.entries.filter((entry) => entry.status === 'completed').length
+    const focus = plan.entries.find((entry) => entry.status === 'in_progress')
+      ?? plan.entries.find((entry) => entry.status !== 'completed')
+      ?? plan.entries.at(-1)
+    return [{
+      id: 'summary',
+      kind: 'generic',
+      title: `Plan · ${completed}/${total}${focus ? ` · ${focus.content}` : ''}`,
+      body: '',
+      action: { kind: 'command', name: 'plan-view', args: '' },
+      ...(completed === total ? { status: 'ok' } : { status: 'running' }),
+    }]
+  }
+  return [{
+    id: 'summary',
+    kind: 'generic',
+    title: plan.kind === 'file' ? `Plan · ${plan.uri}` : 'Plan · available',
+    body: '',
+    action: { kind: 'command', name: 'plan-view', args: '' },
+    status: 'running',
+  }]
+}
+
+function viewNodes(plan) {
+  if (plan === null) {
+    return [{ id: 'empty', kind: 'notice', level: 'info', text: 'No active plan' }]
+  }
+  if (plan.kind === 'markdown') {
+    return [{ id: 'content', kind: 'markdown', text: plan.content }]
+  }
+  if (plan.kind === 'file') {
+    return [{ id: 'file', kind: 'notice', level: 'info', text: plan.uri }]
+  }
+  return plan.entries.map((entry, index) => ({
+    id: `step-${index + 1}`,
+    kind: 'generic',
+    title: entry.content,
+    body: entry.priority ? `priority · ${entry.priority}` : '',
+    ...nodeStatus(entry.status),
+  }))
+}
+
+function nodeStatus(status) {
+  if (status === 'completed') return { status: 'ok' }
+  if (status === 'in_progress') return { status: 'running' }
+  if (status === 'cancelled' || status === 'failed') return { status: 'err' }
+  return {}
+}

package/lib/profile-acp-client.js

@@ -0,0 +1,11 @@
+/** Profile sibling that selects the linked ACP + Creator dependency stack. */
+
+import { apply as applyAcpClient } from './acp-client.js'
+import { resolveStackedAgent } from './agent.js'
+
+export const name = 'dsh-tui-profile-acp-client'
+export const inject = []
+
+export function apply(ctx) {
+  return applyAcpClient(ctx, { agent: resolveStackedAgent() })
+}

package/lib/right-demo.js

@@ -0,0 +1,55 @@
+/** A deliberately rich `chrome.right` gallery; not mounted by default. */
+
+export const name = 'tui-right-slot-gallery'
+export const inject = ['tuiSlots']
+
+export function apply(ctx) {
+  ctx.tuiSlots.inject('chrome.right', () => {
+    const panel = ctx.tuiSlots.register(
+      { name: 'chrome.right', id: 'slot-gallery', order: 10 },
+      [
+        {
+          id: 'mission-control',
+          kind: 'group',
+          title: 'Mission Control',
+          tone: 'brand',
+          children: [
+            {
+              id: 'intro',
+              kind: 'markdown',
+              text: '**Live plugin canvas**\n\nAnything below is owned by one sibling Cordis plugin.',
+            },
+            {
+              id: 'tests',
+              kind: 'generic',
+              title: 'Regression suite',
+              body: '247 checks passed',
+              status: 'ok',
+            },
+            {
+              id: 'deploy',
+              kind: 'terminal',
+              title: 'Preview deploy',
+              body: '$ dsh plugin run slot-gallery\nmounted chrome.right\nwatching source…',
+              exit: 0,
+            },
+            {
+              id: 'patch',
+              kind: 'diff',
+              title: 'Live patch',
+              path: 'client/plugin.js',
+              unified: '@@ -1 +1 @@\n-static card\n+live TuiNode tree',
+            },
+          ],
+        },
+        {
+          id: 'hint',
+          kind: 'notice',
+          level: 'info',
+          text: 'panel.update(nodes) replaces this view immediately; unload removes the rail.',
+        },
+      ],
+    )
+    return panel.dispose
+  })
+}