dsh-tower 2.1.0 → 2.3.0

package/ui-bundle/client.dock.js

@@ -0,0 +1,333 @@
+// dsh-tower-ui 0.2.2 — the composer dock surface (#11 + latest summary).
+//
+// The chip is history-derived; the dock only reads the `useChat` legacy slice
+// and never polls or fetches Host state. Package-local chunk (#71).
+window.__ModuleLoader__.load({
+  id: 'dsh-tower-ui',
+  chunk: 'client.dock.js',
+  factory() {
+    function createDock(env) {
+      const { React, h, translate, toolLabel, seatT, ST, dotStyle, helpers, mode } = env
+      const { modeModelFromLegacy } = env
+      const {
+        isPlainObject,
+        parsePayload,
+        isTowerTool,
+        countsOf,
+        toneForStatus,
+        shortCommit,
+        blockersOf,
+      } = helpers
+      const { nextDockWriter, publishMode, clearMode } = mode
+
+      function renderDockHint(t) {
+        return h(
+          'div',
+          {
+            'data-tower-ui': 'dock-hint',
+            title: translate(t, 'dock.hint.title'),
+            style: ST.hint,
+          },
+          h('span', { 'aria-hidden': true }, '⌘'),
+          h('span', null, '/tower'),
+        )
+      }
+      function latestTowerSignal(legacy) {
+        if (!isPlainObject(legacy)) return null
+        const running = Array.isArray(legacy.runningCalls) ? legacy.runningCalls : []
+        for (let index = running.length - 1; index >= 0; index -= 1) {
+          const block = running[index]
+          if (isPlainObject(block) && isTowerTool(block.name)) return { name: block.name, phase: 'start', block }
+        }
+        const nodes = Array.isArray(legacy.nodes) ? legacy.nodes : []
+        for (let index = nodes.length - 1; index >= 0; index -= 1) {
+          const block = nodes[index]
+          const name = isPlainObject(block) && isPlainObject(block.call) ? block.call.name : undefined
+          if (isTowerTool(name)) return { name, phase: 'result', block }
+        }
+        return null
+      }
+      function dockResultModel(toolName, payload) {
+        if (!isPlainObject(payload)) return { tool: toolName, running: false, tone: 'none', key: 'dock.generic' }
+        if (payload.__error === true) return { tool: toolName, running: false, tone: 'error', key: 'dock.generic' }
+        if (typeof payload.text === 'string') {
+          return { tool: toolName, running: false, tone: 'idle', key: 'dock.generic' }
+        }
+        const blockers = blockersOf(payload.blockers)
+        if (toolName === 'tower_status') {
+          const counts = countsOf(payload)
+          const open = typeof payload.openTasks === 'number' ? payload.openTasks : 0
+          if (counts !== null) {
+            return { tool: toolName, running: false, tone: open > 0 ? 'warn' : 'ok', key: 'dock.statusCounts', params: { total: counts.total, active: counts.active, open } }
+          }
+          return { tool: toolName, running: false, tone: 'ok', key: 'dock.generic' }
+        }
+        if (toolName === 'tower_roster') {
+          const roster = Array.isArray(payload.roster) ? payload.roster : []
+          let live = 0
+          for (const entry of roster) if (isPlainObject(entry) && entry.activity === 'running') live += 1
+          return { tool: toolName, running: false, tone: live > 0 ? 'ok' : 'idle', key: 'dock.rosterCounts', params: { live, total: roster.length } }
+        }
+        if (toolName === 'tower_review' && isPlainObject(payload.review)) {
+          return {
+            tool: toolName,
+            running: false,
+            tone: toneForStatus(payload.review.status),
+            key: 'dock.review',
+            params: {
+              status: typeof payload.review.status === 'string' ? payload.review.status : '?',
+              merge: typeof payload.review.mergeVerdict === 'string' ? payload.review.mergeVerdict : '?',
+            },
+          }
+        }
+        if (toolName === 'tower_preflight') {
+          return payload.ok === true
+            ? { tool: toolName, running: false, tone: 'ok', key: 'dock.ready' }
+            : { tool: toolName, running: false, tone: 'error', key: 'dock.blocked', params: { count: blockers.length } }
+        }
+        if (toolName === 'tower_merge') {
+          return payload.ok === true
+            ? { tool: toolName, running: false, tone: 'ok', key: 'dock.merged', params: { commit: shortCommit(payload.mergedCommit) } }
+            : { tool: toolName, running: false, tone: 'error', key: 'dock.blocked', params: { count: blockers.length } }
+        }
+        if (toolName === 'tower_complete' && isPlainObject(payload.mission)) {
+          return {
+            tool: toolName,
+            running: false,
+            tone: 'ok',
+            key: 'dock.complete',
+            params: { mission: typeof payload.mission.id === 'string' ? payload.mission.id : '?', commits: typeof payload.commits === 'number' ? payload.commits : 0 },
+          }
+        }
+        if (toolName === 'tower_mission' && isPlainObject(payload.mission)) {
+          return {
+            tool: toolName,
+            running: false,
+            tone: toneForStatus(payload.mission.status),
+            key: 'dock.mission',
+            params: { id: typeof payload.mission.id === 'string' ? payload.mission.id : '?', status: typeof payload.mission.status === 'string' ? payload.mission.status : '?' },
+          }
+        }
+        if (toolName === 'tower_spawn') {
+          return {
+            tool: toolName,
+            running: false,
+            tone: 'ok',
+            key: 'dock.spawn',
+            params: {
+              role: typeof payload.role === 'string' ? payload.role : '?',
+              name: typeof payload.name === 'string' ? payload.name : '?',
+              mission: typeof payload.missionId === 'string' ? payload.missionId : '?',
+            },
+          }
+        }
+        if (toolName === 'tower_teardown') {
+          return {
+            tool: toolName,
+            running: false,
+            tone: 'ok',
+            key: 'dock.removed',
+            params: { count: Array.isArray(payload.removed) ? payload.removed.length : 0 },
+          }
+        }
+        if (toolName === 'tower_interrupt') {
+          const name = isPlainObject(payload.entry) && typeof payload.entry.name === 'string' ? payload.entry.name : '?'
+          return payload.interrupted === true
+            ? { tool: toolName, running: false, tone: 'warn', key: 'dock.interrupt', params: { name } }
+            : { tool: toolName, running: false, tone: 'idle', key: 'dock.generic' }
+        }
+        if (toolName === 'tower_doctor') {
+          return {
+            tool: toolName,
+            running: false,
+            tone: payload.ok === true ? 'ok' : 'warn',
+            key: 'dock.doctor',
+            params: { status: payload.ok === true ? 'ok' : 'issues' },
+          }
+        }
+        if (toolName === 'tower_batch') {
+          const summary = isPlainObject(payload.summary) ? payload.summary : isPlainObject(payload.batch) ? payload.batch : null
+          const failed = summary !== null && Array.isArray(summary.failedChecks) ? summary.failedChecks.length : 0
+          const pending = summary !== null && Array.isArray(summary.pendingChecks) ? summary.pendingChecks.length : 0
+          const tone = payload.ok === true && failed === 0 && pending === 0 ? 'ok' : failed > 0 ? 'error' : 'warn'
+          return {
+            tool: toolName,
+            running: false,
+            tone,
+            key: 'dock.batch',
+            params: { status: summary !== null && typeof summary.status === 'string' ? summary.status : payload.ok === true ? 'ok' : 'issues' },
+          }
+        }
+        return { tool: toolName, running: false, tone: 'idle', key: 'dock.generic' }
+      }
+      function dockSelector(snapshot) {
+        try {
+          const legacy = snapshot ? snapshot.legacy : undefined
+          const modeModel = modeModelFromLegacy(legacy, helpers)
+          let summary = null
+          // While the chip is on it is the dock's message; the summary returns
+          // after /tower off.
+          if (!(modeModel.known === true && modeModel.on === true)) {
+            const signal = latestTowerSignal(legacy)
+            if (signal !== null) {
+              summary =
+                signal.phase !== 'result'
+                  ? { tool: signal.name, running: true, tone: 'idle' }
+                  : dockResultModel(signal.name, parsePayload(signal.block))
+            }
+          }
+          return JSON.stringify({
+            mode: modeModel,
+            summary,
+            // A Tower result with no mode event cannot prove the stance; surface
+            // that explicitly instead of pretending the session is off.
+            uncertain: modeModel.known !== true && summary !== null && summary.running !== true,
+          })
+        } catch (error) {
+          return ''
+        }
+      }
+      function modeStorageKey(sessionId) {
+        return 'dsh-tower-ui:mode:' + String(sessionId)
+      }
+      function readStoredMode(sessionId) {
+        if (typeof sessionId !== 'string' || sessionId === '') return null
+        try {
+          const raw = globalThis.localStorage && globalThis.localStorage.getItem(modeStorageKey(sessionId))
+          if (!raw) return null
+          const parsed = JSON.parse(raw)
+          if (!isPlainObject(parsed) || typeof parsed.at !== 'number') return null
+          if (Date.now() - parsed.at > 7 * 24 * 60 * 60 * 1000) return null
+          return parsed
+        } catch {
+          return null
+        }
+      }
+      function writeStoredMode(sessionId, current) {
+        if (typeof sessionId !== 'string' || sessionId === '') return
+        try {
+          if (!globalThis.localStorage) return
+          if (current.known === true && (current.on === true || current.on === false)) {
+            globalThis.localStorage.setItem(modeStorageKey(sessionId), JSON.stringify({
+              on: current.on,
+              denied: current.denied ?? null,
+              repo: current.repo ?? null,
+              lock: current.lock ?? null,
+              lastBy: current.lastBy ?? null,
+              lastReason: current.lastReason ?? null,
+              at: Date.now(),
+            }))
+          }
+        } catch {
+          // storage is best effort; the history-derived model remains the source
+        }
+      }
+      function modeTooltip(t, modeModel) {
+        const parts = [translate(t, 'dock.mode.tooltip')]
+        if (modeModel.source === 'stored') parts.push(translate(t, 'dock.mode.lastKnown'))
+        if (typeof modeModel.repo === 'string' && modeModel.repo !== '') parts.push(translate(t, 'dock.mode.repo', { repo: modeModel.repo }))
+        if (isPlainObject(modeModel.lock)) {
+          parts.push(translate(t, modeModel.lock.held === true ? 'dock.mode.lockHeld' : 'dock.mode.lockFree'))
+        }
+        if (typeof modeModel.lastBy === 'string' && modeModel.lastBy !== '') parts.push(translate(t, 'dock.mode.lastBy', { by: modeModel.lastBy }))
+        return parts.join(translate(t, 'card.sep'))
+      }
+      function renderModeChip(t, modeModel) {
+        // Non-interactive on purpose: inputActions.submit() would submit (and
+        // clobber) the composer draft; the tooltip is the affordance instead.
+        return h(
+          'div',
+          {
+            'data-tower-ui': 'dock-mode',
+            'data-tower-mode': modeModel.on === true ? 'on' : 'off',
+            role: 'status',
+            'aria-live': 'polite',
+            title: modeTooltip(t, modeModel),
+            style: ST.modeChip,
+          },
+          h('span', { 'aria-hidden': true, style: dotStyle('ok') }),
+          h('span', { style: ST.modeChipLabel }, translate(t, 'card.title')),
+          h('span', { style: ST.dim }, '·'),
+          h('span', { style: ST.modeChipOn }, translate(t, 'dock.mode.onLabel')),
+        )
+      }
+      function renderModeUnknown(t) {
+        return h(
+          'div',
+          {
+            'data-tower-ui': 'dock-mode',
+            'data-tower-mode': 'unknown',
+            role: 'status',
+            'aria-live': 'polite',
+            title: translate(t, 'dock.mode.unknownTooltip'),
+            style: ST.modeChip,
+          },
+          h('span', { 'aria-hidden': true, style: dotStyle('idle') }),
+          h('span', { style: ST.modeChipLabel }, translate(t, 'card.title')),
+          h('span', { style: ST.dim }, '·'),
+          h('span', { style: ST.modeChipOn }, translate(t, 'dock.mode.unknownLabel')),
+        )
+      }
+      function TowerDock(props) {
+        const t = seatT(props)
+        if (!props || typeof props.useChat !== 'function') return renderDockHint(t)
+        return h(TowerDockLive, Object.assign({}, props, { t }))
+      }
+      function TowerDockLive(props) {
+        const t = seatT(props)
+        const raw = props.useChat(dockSelector)
+        let model = null
+        if (typeof raw === 'string' && raw !== '') {
+          try {
+            model = JSON.parse(raw)
+          } catch (error) {
+            model = null
+          }
+        }
+        const modeFromHistory = isPlainObject(model) && isPlainObject(model.mode) ? model.mode : { known: false, on: null }
+        const stored = modeFromHistory.known !== true ? readStoredMode(props.sessionId) : null
+        const current = stored
+          ? Object.assign({}, modeFromHistory, stored, { known: true, source: 'stored' })
+          : modeFromHistory
+        writeStoredMode(props.sessionId, modeFromHistory)
+        const writerState = React.useState(function () {
+          return nextDockWriter()
+        })
+        const writer = writerState[0]
+        React.useEffect(
+          function () {
+            // Publish only the history-derived stance. A stored last-known value
+            // is display-only: it must not shadow native toolviews.
+            publishMode(writer, modeFromHistory)
+            return function () {
+              clearMode(writer)
+            }
+          },
+          [JSON.stringify(modeFromHistory)],
+        )
+        if (current.known === true && current.on === true) return renderModeChip(t, current)
+        if (isPlainObject(model) && model.uncertain === true) return renderModeUnknown(t)
+        const summary = isPlainObject(model) ? model.summary : null
+        if (!isPlainObject(summary)) return renderDockHint(t)
+        const text = summary.running === true
+          ? translate(t, 'dock.running', { tool: toolLabel(t, summary.tool) })
+          : summary.key
+            ? translate(t, summary.key, summary.params)
+            : translate(t, 'dock.generic')
+        const tone = summary.running === true ? 'idle' : summary.tone
+        return h(
+          'div',
+          { 'data-tower-ui': 'dock', style: ST.dock, title: toolLabel(t, summary.tool) + translate(t, 'card.sep') + text },
+          h('span', { 'aria-hidden': true, style: dotStyle(tone) }),
+          h('span', { style: ST.dockTool }, toolLabel(t, summary.tool)),
+          h('span', { style: ST.dim }, '·'),
+          h('span', { style: ST.dockText }, text),
+        )
+      }
+
+      return { TowerDock }
+    }
+
+    return { createDock }
+  },
+})

package/ui-bundle/client.helpers.js

@@ -0,0 +1,271 @@
+// dsh-tower-ui 0.2.2 — tool vocabulary and the defensive payload helpers.
+//
+// Every helper is defensive: a tool result is durable user-facing data and may
+// be an older shape, a partial stream, an error, or plain text instead of
+// JSON. Package-local chunk loaded by client.js (#71); the translation helpers
+// are injected once so the module stays free of top-level state.
+window.__ModuleLoader__.load({
+  id: 'dsh-tower-ui',
+  chunk: 'client.helpers.js',
+  factory() {
+    const MAX_TEXT = 150
+    const TOOL_NAMES = [
+      'tower_status',
+      'tower_roster',
+      'tower_spawn',
+      'tower_mission',
+      'tower_complete',
+      'tower_review',
+      'tower_preflight',
+      'tower_merge',
+      'tower_teardown',
+      'tower_interrupt',
+      'tower_doctor',
+      'tower_batch',
+    ]
+    const TOOL_SET = new Set(TOOL_NAMES)
+    // Mirrors host/config.js DEFAULT_DENY_TOOLS; overridden by the
+    // `deniedWhileActive` list of the latest `tower_mode` output when present.
+    const DEFAULT_DENIED_TOOLS = [
+      'create_goal',
+      'todo_write',
+      'team_task_create',
+      'team_task_update',
+      'team_task_reopen',
+      'team_task_list',
+      'spawn_teammate',
+      'wait_agent',
+      'workflow',
+      'ralph',
+      'subagent',
+      'subagent_fork',
+    ]
+
+    function createHelpers(translate) {
+      function isTowerTool(name) {
+        return typeof name === 'string' && TOOL_SET.has(name)
+      }
+      function truncate(value, max) {
+        const text = String(value === undefined || value === null ? '' : value)
+          .replace(/\s+/g, ' ')
+          .trim()
+        const limit = max === undefined ? MAX_TEXT : max
+        return text.length > limit ? text.slice(0, limit - 1) + '…' : text
+      }
+      function firstLine(value, max) {
+        const text = String(value === undefined || value === null ? '' : value)
+        const line = text.split('\n')[0]
+        return truncate(line, max)
+      }
+      function shortCommit(value) {
+        if (typeof value !== 'string' || value === '') return ''
+        return value.slice(0, 7)
+      }
+      function isPlainObject(value) {
+        return value !== null && typeof value === 'object' && !Array.isArray(value)
+      }
+      function textOfBlock(block) {
+        if (!isPlainObject(block)) return ''
+        const parts = []
+        if (Array.isArray(block.content)) {
+          for (const item of block.content) {
+            if (!isPlainObject(item)) continue
+            if (typeof item.text === 'string') parts.push(item.text)
+          }
+        }
+        if (parts.length === 0 && typeof block.text === 'string') parts.push(block.text)
+        return parts.join('\n')
+      }
+      function errorOfBlock(block) {
+        if (!isPlainObject(block)) return null
+        if (isPlainObject(block.error)) return block.error
+        if (block.isError === true) return { name: 'ToolError', code: 'error' }
+        return null
+      }
+      function parsePayload(block) {
+        if (!isPlainObject(block)) return null
+        const error = errorOfBlock(block)
+        if (error !== null) return { __error: true, error }
+        const text = textOfBlock(block).trim()
+        if (text === '') return null
+        if (text[0] === '{' || text[0] === '[') {
+          try {
+            const parsed = JSON.parse(text)
+            if (isPlainObject(parsed)) return parsed
+            if (Array.isArray(parsed)) return { items: parsed }
+          } catch (error) {
+            /* fall through to text */
+          }
+        }
+        return { text }
+      }
+      function blockersOf(value) {
+        if (!Array.isArray(value)) return []
+        const out = []
+        for (const entry of value) {
+          if (typeof entry === 'string' && entry.trim() !== '') out.push(entry.trim())
+          else if (isPlainObject(entry)) {
+            const code = typeof entry.code === 'string' ? entry.code : 'blocker'
+            const detail = typeof entry.detail === 'string' ? entry.detail : ''
+            out.push(detail === '' ? code : code + ': ' + detail)
+          }
+        }
+        return out
+      }
+      function missionBlocksOf(value) {
+        if (!Array.isArray(value)) return []
+        return value.filter((entry) => typeof entry === 'string' && entry.trim() !== '').map((entry) => entry.trim())
+      }
+      function countsOf(payload) {
+        if (!isPlainObject(payload) || !isPlainObject(payload.counts)) return null
+        const counts = payload.counts
+        let total = 0
+        const byStatus = {}
+        let hasAny = false
+        for (const key of Object.keys(counts)) {
+          const value = counts[key]
+          if (typeof value !== 'number' || !Number.isFinite(value)) continue
+          hasAny = true
+          byStatus[key] = value
+          total += value
+        }
+        if (!hasAny) return null
+        return { total, byStatus, active: typeof byStatus.active === 'number' ? byStatus.active : 0 }
+      }
+      function taskCountsOf(tasks) {
+        if (Array.isArray(tasks)) {
+          const counts = { total: tasks.length, done: 0, open: 0, dropped: 0 }
+          for (const task of tasks) {
+            const status = isPlainObject(task) ? task.status : undefined
+            if (status === 'done') counts.done += 1
+            else if (status === 'dropped') counts.dropped += 1
+            else counts.open += 1
+          }
+          return counts
+        }
+        if (isPlainObject(tasks)) {
+          const total = typeof tasks.total === 'number' ? tasks.total : null
+          if (total === null) return null
+          const done = typeof tasks.done === 'number' ? tasks.done : 0
+          const open = typeof tasks.open === 'number' ? tasks.open : Math.max(0, total - done - (typeof tasks.dropped === 'number' ? tasks.dropped : 0))
+          return { total, done, open, dropped: typeof tasks.dropped === 'number' ? tasks.dropped : 0 }
+        }
+        return null
+      }
+      function toneForStatus(status) {
+        if (typeof status !== 'string') return 'none'
+        if (/^(merged|completed|clean|done|fixed|ok)$/.test(status)) return 'ok'
+        if (/^(blocked|abandoned|failed)$/.test(status) || /^p1-/.test(status)) return 'error'
+        if (/^(paused|stale|missing|p2-)/.test(status)) return 'warn'
+        return 'idle'
+      }
+      function toneForPayload(payload) {
+        if (!isPlainObject(payload)) return 'none'
+        if (payload.ok === false) return 'error'
+        if (blockersOf(payload.blockers).length > 0) return 'error'
+        if (payload.ok === true) return 'ok'
+        if (isPlainObject(payload.review)) return toneForStatus(payload.review.status)
+        if (isPlainObject(payload.mission)) return toneForStatus(payload.mission.status)
+        if (isPlainObject(payload.review) === false && payload.review === null) return 'idle'
+        return 'idle'
+      }
+      function checkEntries(checks) {
+        if (!Array.isArray(checks)) return []
+        const out = []
+        for (const entry of checks) {
+          if (typeof entry === 'string') {
+            const text = entry.trim()
+            if (text !== '') out.push({ name: truncate(text, 80), ok: null, code: null, detail: '' })
+            continue
+          }
+          if (!isPlainObject(entry)) continue
+          const name =
+            typeof entry.name === 'string' && entry.name !== ''
+              ? entry.name
+              : typeof entry.id === 'string' && entry.id !== ''
+                ? entry.id
+                : 'check'
+          const code = typeof entry.exitCode === 'number' ? entry.exitCode : null
+          const ok =
+            code !== null
+              ? code === 0
+              : entry.status === 'pass'
+                ? true
+                : entry.status === 'fail'
+                  ? false
+                  : entry.ok === true
+                    ? true
+                    : entry.ok === false
+                      ? false
+                      : null
+          out.push({
+            name: truncate(name, 80),
+            ok,
+            code,
+            detail: typeof entry.detail === 'string' ? entry.detail : typeof entry.evidence === 'string' ? entry.evidence : '',
+          })
+        }
+        return out
+      }
+      function checkText(t, entry) {
+        const base =
+          entry.code !== null
+            ? translate(t, entry.ok ? 'card.checkOk' : 'card.checkFail', {
+                name: entry.name,
+                code: entry.code,
+              })
+            : entry.name
+        return entry.detail ? truncate(base + ': ' + entry.detail, 120) : base
+      }
+      function checkSummary(t, checks) {
+        const entries = checkEntries(checks)
+        if (entries.length === 0) return ''
+        const passed = entries.filter((entry) => entry.ok === true).length
+        const known = entries.filter((entry) => entry.ok !== null).length
+        if (known > 0) return translate(t, 'card.checksCount', { passed, total: known })
+        return String(entries.length)
+      }
+      function missionLine(t, mission) {
+        if (!isPlainObject(mission)) return ''
+        const id = typeof mission.id === 'string' ? mission.id : translate(t, 'card.missionMissing')
+        const status = typeof mission.status === 'string' ? mission.status : translate(t, 'card.unknown')
+        const parts = [translate(t, 'card.missionLine', { id, status })]
+        const tasks = taskCountsOf(mission.tasks)
+        if (tasks !== null && tasks.total > 0) {
+          parts.push(translate(t, 'card.tasks', { done: tasks.done, total: tasks.total }))
+        }
+        if (missionBlocksOf(mission.blockers).length > 0) {
+          parts.push(String(missionBlocksOf(mission.blockers).length) + ' ⚠')
+        }
+        return parts.join(translate(t, 'card.sep'))
+      }
+
+      return {
+        MAX_TEXT,
+        TOOL_NAMES,
+        TOOL_SET,
+        DEFAULT_DENIED_TOOLS,
+        isTowerTool,
+        truncate,
+        firstLine,
+        shortCommit,
+        isPlainObject,
+        textOfBlock,
+        errorOfBlock,
+        parsePayload,
+        blockersOf,
+        missionBlocksOf,
+        countsOf,
+        taskCountsOf,
+        toneForStatus,
+        toneForPayload,
+        checkEntries,
+        checkText,
+        checkSummary,
+        missionLine,
+      }
+    }
+
+    return { MAX_TEXT, TOOL_NAMES, TOOL_SET, DEFAULT_DENIED_TOOLS, createHelpers }
+  },
+})