dsh-tower 2.1.0-beta.1 → 2.3.0

package/ui-bundle/client.toolview.js

@@ -0,0 +1,82 @@
+// dsh-tower-ui 0.2.2 — the toolview card surface (one keyed view per tool).
+//
+// The chat-driven card publishes lifecycle transitions into the notice store
+// the root-scoped overlay injects. Package-local chunk (#71).
+window.__ModuleLoader__.load({
+  id: 'dsh-tower-ui',
+  chunk: 'client.toolview.js',
+  factory() {
+    function createToolview(env) {
+      const { React, h, translate, toolLabel, seatT, ST, dotStyle, helpers, cards, notice } = env
+      const { isTowerTool, parsePayload, isPlainObject, truncate } = helpers
+      const { rowElement, cardModel } = cards
+      const publishNotice = notice.publish
+
+      // Mounting an already-settled result (history) stays silent; a live
+      // preparing/start row and a start→result transition publish.
+      function useToolviewLifecycle(props) {
+        const phase = props ? props.phase : undefined
+        const toolName = props ? props.toolName : undefined
+        const callId = props ? props.callId : undefined
+        const failed = Boolean(props && props.block && (props.block.isError === true || isPlainObject(props.block.error)))
+        const previous = React.useRef ? React.useRef(null) : { current: null }
+        React.useEffect(
+          function () {
+            const before = previous.current
+            previous.current = { phase, callId }
+            if (!isTowerTool(toolName)) return
+            const sameCall = before !== null && before.callId === callId
+            if (phase !== 'result') {
+              if (!sameCall || before.phase !== phase) publishNotice({ tool: toolName, running: true })
+            } else if (sameCall && before.phase !== 'result') {
+              publishNotice({ tool: toolName, running: false, ok: failed !== true })
+            }
+          },
+          [phase, callId, toolName, failed],
+        )
+      }
+
+      function TowerToolCard(props) {
+        const t = seatT(props)
+        const toolName = props && typeof props.toolName === 'string' ? props.toolName : ''
+        const phase = props && typeof props.phase === 'string' ? props.phase : 'start'
+        const running = phase !== 'result'
+        useToolviewLifecycle(props)
+        let payload = null
+        if (!running) payload = parsePayload(props ? props.block : undefined)
+        const model = running
+          ? { tone: 'idle', headline: translate(t, 'card.running'), rows: [] }
+          : cardModel(toolName, payload, t)
+        const title =
+          toolLabel(t, toolName) +
+          ' · ' +
+          (running ? translate(t, 'card.running') : model.headline)
+        return h(
+          'div',
+          {
+            'data-tower-toolview': toolName === '' ? 'tower_unknown' : toolName,
+            'data-tower-phase': phase,
+            style: ST.card,
+            title,
+          },
+          h(
+            'div',
+            { style: ST.header },
+            h('span', { 'aria-hidden': true, style: dotStyle(running ? 'idle' : model.tone) }),
+            h('span', { style: ST.title }, translate(t, 'card.title')),
+            h('span', { style: ST.dim }, '·'),
+            h('span', { style: ST.title }, toolLabel(t, toolName)),
+            h('span', { style: running ? ST.dim : model.tone === 'error' ? ST.rowError : ST.dim }, truncate(model.headline, 100)),
+          ),
+          model.rows.slice(0, 6).map(function (row, index) {
+            return rowElement(t, index, row)
+          }),
+        )
+      }
+
+      return { TowerToolCard }
+    }
+
+    return { createToolview }
+  },
+})

package/ui-bundle/package.json

@@ -13,6 +13,7 @@
   "files": [
     "index.js",
     "client.js",
+    "client.*.js",
     "cordis.patch.yml",
     "locale/*.json",
     "icon.svg",

package/lib/doctor.js

@@ -1,270 +0,0 @@
-// Read-only environment contract and health checks for a Tower repository.
-import { execFile } from '../adapters/vcs-git.js'
-import { promisify } from 'node:util'
-import path from 'node:path'
-import { fsp } from '../adapters/store-fs.js'
-import { git } from './git.js'
-import { readStateLock } from './store.js'
-import { assessHostVersion, detectHostVersion, readCompatibility } from './compatibility.js'
-import { profileConfig } from './config.js'
-import { inspectWorkspaceLock } from './workspaceLock.js'
-
-const execFileAsync = promisify(execFile)
-
-async function exists(target) {
-  try {
-    await fsp.stat(target)
-    return true
-  } catch {
-    return false
-  }
-}
-
-async function gitVersion() {
-  try {
-    const { stdout } = await execFileAsync('git', ['--version'], { windowsHide: true })
-    return String(stdout).trim()
-  } catch {
-    return null
-  }
-}
-
-function check(id, status, detail, action) {
-  return { id, status, detail, ...(action ? { action } : {}) }
-}
-
-/** Run every read-only diagnostic; never writes state or takes the state lock. */
-export async function runDoctor({ tower, ctx, agent, hostVersion, compatibilityFile, loaderRows }) {
-  const checks = []
-  const version = await gitVersion()
-  checks.push(version ? check('git', 'pass', version) : check('git', 'fail', 'git is not available', 'install Git and retry'))
-
-  const detectedHost = hostVersion ?? detectHostVersion(ctx)
-  const compatibilityRows = readCompatibility(compatibilityFile)
-  const hostAssessment = assessHostVersion(detectedHost, compatibilityRows)
-  checks.push(
-    check(
-      'host-version',
-      hostAssessment.verdict === 'verified' ? 'pass' : 'warn',
-      detectedHost
-        ? `${detectedHost}: ${hostAssessment.detail}`
-        : `unknown host version; ${hostAssessment.detail}. Include host version + COMPATIBILITY.md row in bug reports.`,
-      'see COMPATIBILITY.md for verified host builds',
-    ),
-  )
-
-  const rows = Array.isArray(loaderRows)
-    ? loaderRows
-    : (() => {
-        try {
-          const loader = ctx?.get?.('loader') ?? ctx?.loader
-          const source = loader?.entries ?? loader?.rows ?? loader?.store?.entries
-          if (Array.isArray(source)) return source
-          if (source && typeof source === 'object') return Object.values(source)
-        } catch {
-          // loader inventory is optional
-        }
-        return null
-      })()
-  if (rows === null) {
-    checks.push(check('loader-conflicts', 'warn', 'loader inventory unavailable; cannot detect co-installed Tower packages'))
-  } else {
-    const towerRows = rows.filter((row) => row && row.name === 'dsh-tower')
-    const foreign = towerRows.filter((row) => row.id !== 'tower')
-    checks.push(
-      towerRows.length > 1 || foreign.length > 0
-        ? check(
-            'loader-conflicts',
-            'fail',
-            `another loader row resolves to "dsh-tower" (${towerRows.map((row) => row.id ?? '?').join(', ')}); uninstall the conflicting dsh-plugins-tower row`,
-            'see README "Known conflicts"',
-          )
-        : check('loader-conflicts', 'pass', 'no conflicting dsh-tower loader rows'),
-    )
-  }
-
-  checks.push(check('repository', 'pass', `${tower.root} (common ${tower.commonDir})`))
-  let state = null
-  try {
-    state = await tower.load()
-    checks.push(check('state', 'pass', `${tower.paths.state} revision ${state.revision}`))
-    checks.push(
-      state.towerAgentId
-        ? check('tower-owner', 'pass', `bound to ${String(state.towerAgentId)}`)
-        : check('tower-owner', 'warn', 'state has no towerAgentId; write tools will fail closed', 'run tower_init with the restored session to re-claim ownership'),
-    )
-  } catch (error) {
-    checks.push(check('state', 'fail', String(error?.message ?? error), 'run tower_init or restore the state file'))
-  }
-
-  const config = tower.config ?? {}
-  const profile = profileConfig()
-  const staleDefaults = []
-  if (profile.review && profile.review.requireReview === undefined) {
-    staleDefaults.push('review.requireReview now defaults to false (2.0.3)')
-  }
-  if (profile.mode && profile.mode.allowAgentControl === undefined) {
-    staleDefaults.push('mode.allowAgentControl now defaults to true (2.0.4)')
-  }
-  checks.push(
-    staleDefaults.length > 0
-      ? check('default-reversals', 'warn', staleDefaults.join('; '), 'pin the key explicitly in the profile if the old posture is required')
-      : check('default-reversals', 'pass', 'profile does not rely on a reversed default'),
-  )
-  checks.push(
-    check(
-      'config',
-      config.configPath && config.repoConfigPresent ? 'pass' : 'warn',
-      config.repoConfigPresent ? `repo config ${config.configPath}` : `repo config not present (${config.configPath ?? 'unknown'})`,
-      'optional: add <git-common-dir>/dsh-tower/config.json',
-    ),
-  )
-  const presets = ctx.get?.('agentPresets')
-  if (presets && typeof presets.list === 'function') {
-    try {
-      const available = (await presets.list()).map((entry) => String(entry.id))
-      const missing = [config.spawn?.workerPreset ?? 'tower-worker', config.spawn?.reviewerPreset ?? 'tower-reviewer']
-        .filter((id) => !available.includes(id))
-      checks.push(
-        missing.length === 0
-          ? check('presets', 'pass', `worker=${config.spawn?.workerPreset ?? 'tower-worker'} reviewer=${config.spawn?.reviewerPreset ?? 'tower-reviewer'}`)
-          : check('presets', 'fail', `missing preset(s): ${missing.join(', ')}`, 'enable the Tower preset bundle and retry'),
-      )
-    } catch (error) {
-      checks.push(check('presets', 'warn', `preset registry unavailable: ${String(error?.message ?? error)}`))
-    }
-  } else {
-    checks.push(check('presets', 'warn', 'agentPresets service is unavailable'))
-  }
-
-  const subagents = ctx.get?.('subagents')
-  checks.push(subagents ? check('subagents', 'pass', 'service mounted') : check('subagents', 'fail', 'subagents service is unavailable', 'enable the subagent bundle'))
-  const hmr = ctx.get?.('hmr')
-  checks.push(hmr ? check('hmr', 'pass', 'service mounted') : check('hmr', 'warn', 'HMR is not mounted; /tower reload is unavailable'))
-
-  if (state) {
-    const lock = await readStateLock(tower.paths)
-    checks.push(
-      !lock.record
-        ? check('state-lock', 'pass', 'no state lock file')
-        : lock.alive === false
-          ? check('state-lock', 'warn', `stale state lock (pid ${lock.record.pid ?? 'unknown'} is gone); the next mutation reclaims it atomically`)
-          : check('state-lock', 'warn', `state lock held by pid ${lock.record.pid ?? 'unknown'}; retry after it finishes`),
-    )
-    const lockDir = path.join(tower.commonDir, 'dsh-tower', 'tower.lock')
-    try {
-      const lock = await inspectWorkspaceLock(tower.commonDir, {
-        staleMs: Number(config.mode?.workspaceStaleMs) || 300000,
-      })
-      checks.push(lock.held ? check('workspace-lock', lock.stale ? 'warn' : 'pass', `held by ${lock.holder?.sessionId ?? 'unknown'}`) : check('workspace-lock', 'pass', 'free'))
-    } catch {
-      checks.push(check('workspace-lock', 'warn', `lock file ${lockDir} could not be inspected`))
-    }
-
-    const live = (state.roster ?? []).filter((entry) => !['retired', 'failed', 'interrupted', 'missing', 'stale', 'inactive'].includes(entry.state))
-    checks.push(
-      live.length > 0
-        ? check('roster', 'pass', `${live.length} live roster entr${live.length === 1 ? 'y' : 'ies'}`)
-        : check('roster', 'pass', 'no live workers'),
-    )
-
-    let missingWorktrees = 0
-    let dirtyWorktrees = 0
-    let removedWorktrees = 0
-    for (const mission of state.missions ?? []) {
-      if (!mission.worktree) continue
-      if (mission.worktreeRemovedAt) {
-        removedWorktrees += 1
-        continue
-      }
-      try {
-        await tower.assertWorktree(mission.worktree)
-        if (await exists(mission.worktree.path)) {
-          const dirty = (await git(mission.worktree.path, ['status', '--porcelain'])).trim()
-          if (dirty) dirtyWorktrees += 1
-        } else {
-          missingWorktrees += 1
-        }
-      } catch {
-        missingWorktrees += 1
-      }
-    }
-    const removedNote = removedWorktrees > 0 ? ` (${removedWorktrees} removed by teardown)` : ''
-    checks.push(
-      missingWorktrees > 0
-        ? check('worktrees', 'fail', `${missingWorktrees} mission worktree(s) are missing or invalid${removedNote}`, 'inspect tower_status, restore the worktree/branch, then re-run tower_doctor')
-        : dirtyWorktrees > 0
-          ? check('worktrees', 'warn', `${dirtyWorktrees} worktree(s) have uncommitted changes${removedNote}`)
-          : check('worktrees', 'pass', `all registered worktrees are valid${removedNote}`),
-    )
-
-    const testConfigured = state.missions?.some((mission) => mission.testRuns !== undefined)
-    checks.push(
-      check(
-        'tests',
-        config.tests?.enabled === false ? 'warn' : 'pass',
-        config.tests?.enabled === false ? 'test discovery disabled' : `admission=${config.tests?.admission ?? 'complete'} timeoutMs=${config.tests?.timeoutMs ?? 60000}${testConfigured ? '; receipts present' : ''}`,
-      ),
-    )
-    checks.push(check('legacy', 'pass', `${state.legacySnapshots?.length ?? 0} legacy snapshot(s)`))
-    checks.push(check('batches', 'pass', `${state.batches?.length ?? 0} batch(es)`))
-  }
-
-  try {
-    const { inspectLeases } = await import('./leases.js')
-    const leases = await inspectLeases(tower.commonDir)
-    checks.push(check('leases', leases.leases?.length ? 'warn' : 'pass', `${leases.leases?.length ?? 0} active lease(s)`))
-  } catch (error) {
-    const corrupt = error?.code === 'state-corrupt'
-    checks.push(
-      check(
-        'leases',
-        corrupt ? 'fail' : 'warn',
-        corrupt ? `lease ledger is corrupt: ${String(error?.message ?? error)}` : 'lease module unavailable',
-        corrupt ? 'inspect <git-common-dir>/dsh-tower/leases.json and repair or remove it' : undefined,
-      ),
-    )
-  }
-
-  try {
-    const text = await fsp.readFile(path.join(tower.paths.dir, 'lock-holds.jsonl'), 'utf8')
-    const samples = text.split('\n').filter(Boolean).slice(-200).map((line) => JSON.parse(line).ms).filter((ms) => Number.isFinite(ms)).sort((a, b) => a - b)
-    if (samples.length === 0) {
-      checks.push(check('lock-holds', 'pass', 'no lock-hold samples yet'))
-    } else {
-      const p = (q) => samples[Math.min(samples.length - 1, Math.floor(q * samples.length))]
-      const p50 = p(0.5)
-      const p95 = p(0.95)
-      checks.push(
-        check(
-          'lock-holds',
-          p95 > 1000 ? 'warn' : 'pass',
-          `${samples.length} sample(s): p50 ${p50}ms, p95 ${p95}ms`,
-          p95 > 1000 ? 'a mutation is holding the state lock across slow work; inspect the activity/lock-holds log' : undefined,
-        ),
-      )
-    }
-  } catch {
-    checks.push(check('lock-holds', 'pass', 'no lock-hold samples yet'))
-  }
-
-  const failed = checks.filter((item) => item.status === 'fail').length
-  return {
-    ok: failed === 0,
-    checks,
-    environmentContract: {
-      platform: process.platform,
-      gitVersion: version,
-      repoRoot: tower.root,
-      commonDir: tower.commonDir,
-      stateDir: tower.paths.dir,
-      gitTimeoutMs: Number(tower.config.git?.timeoutMs) || 15000,
-      mergeTimeoutMs: Number(tower.config.merge?.timeoutMs) || 900000,
-      testsAdmission: tower.config.tests?.admission ?? 'off',
-      hostVersion: detectedHost,
-      hostCompatibility: hostAssessment.verdict,
-      hostCompatibilityDetail: hostAssessment.detail,
-    },
-    mode: agent ? 'ready' : 'unknown',
-  }
-}