dsh-hitl 0.1.0

package/tests/pending.test.js

@@ -0,0 +1,240 @@
+import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
+
+import { ERROR_CODES, OUTCOMES } from '../lib/protocol.js'
+import { createPendingRegistry, timeoutDecision } from '../lib/pending.js'
+
+/** Deterministic clock/timers so seconds pass in one call. */
+function fakeClock() {
+  let current = 0
+  let nextId = 1
+  const timers = new Map()
+  return {
+    now: () => current,
+    setTimer: (callback, delay) => {
+      const id = nextId
+      nextId += 1
+      timers.set(id, { at: current + Math.max(0, delay), callback })
+      return id
+    },
+    clearTimer: id => { timers.delete(id) },
+    pendingTimers: () => timers.size,
+    advance(ms) {
+      const target = current + ms
+      for (let guard = 0; guard < 1000; guard += 1) {
+        let next
+        for (const [id, timer] of timers) {
+          if (timer.at <= target && (next === undefined || timer.at < next.timer.at)) next = { id, timer }
+        }
+        if (next === undefined) break
+        timers.delete(next.id)
+        current = next.timer.at
+        next.timer.callback()
+      }
+      current = target
+    },
+  }
+}
+
+/** One registry wired to a fake clock and the settlements it produced. */
+function registryOf(options = {}) {
+  const clock = fakeClock()
+  const settlements = []
+  const registry = createPendingRegistry({
+    now: clock.now,
+    setTimer: clock.setTimer,
+    clearTimer: clock.clearTimer,
+    onSettle: (entry, settlement) => { settlements.push({ id: entry.id, request: entry.request, ...settlement }) },
+    ...options,
+  })
+  return { clock, settlements, registry }
+}
+
+const REQUEST = { id: 'r1', sessionId: 's1', toolName: 'bash', countdown: null }
+
+describe('pending: settlement', () => {
+  it('accepts the first decision and reports later ones', () => {
+    const { registry, settlements } = registryOf()
+    assert.deepEqual(registry.open({ id: 'r1', request: REQUEST, countdown: null, onTimeout: undefined }), { ok: true, expiresAt: undefined })
+    assert.equal(registry.has('r1'), true)
+    assert.deepEqual(registry.list(), [REQUEST])
+    assert.equal(registry.size(), 1)
+    assert.deepEqual(registry.settle('r1', { kind: 'approve' }), { accepted: true })
+    assert.equal(registry.has('r1'), false)
+    assert.equal(registry.size(), 0)
+    assert.deepEqual(settlements, [{ id: 'r1', request: REQUEST, decision: { kind: 'approve' }, source: OUTCOMES.user }])
+    assert.deepEqual(registry.settle('r1', { kind: 'reject' }), { accepted: false, code: ERROR_CODES.alreadySettled })
+    assert.deepEqual(registry.settle('nope', { kind: 'reject' }), { accepted: false, code: ERROR_CODES.unknownRequest })
+    assert.deepEqual(registry.settled(), ['r1'])
+  })
+
+  it('refuses a duplicate identity', () => {
+    const { registry } = registryOf()
+    registry.open({ id: 'r1', request: REQUEST, countdown: null })
+    assert.deepEqual(registry.open({ id: 'r1', request: REQUEST, countdown: null }), { ok: false, code: ERROR_CODES.alreadySettled })
+  })
+
+  it('exposes the open request until it settles', () => {
+    const { registry } = registryOf()
+    registry.open({ id: 'r1', request: REQUEST, countdown: null })
+    assert.equal(registry.get('r1'), REQUEST)
+    registry.settle('r1', { kind: 'approve' })
+    assert.equal(registry.get('r1'), undefined)
+  })
+})
+
+describe('pending: countdown', () => {
+  it('maps the three actions', () => {
+    assert.deepEqual(timeoutDecision('approve'), { kind: 'approve' })
+    assert.deepEqual(timeoutDecision('reject'), { kind: 'reject' })
+    assert.deepEqual(timeoutDecision('notify'), { kind: 'reject' })
+  })
+
+  it('settles at the deadline with the configured action', () => {
+    const { registry, clock, settlements } = registryOf()
+    const opened = registry.open({
+      id: 'r1', request: REQUEST, countdown: { remainingMs: 30000, action: 'notify', freezeOnInteract: true },
+    })
+    assert.deepEqual(opened, { ok: true, expiresAt: 30000 })
+    clock.advance(29999)
+    assert.equal(registry.size(), 1)
+    clock.advance(1)
+    assert.deepEqual(settlements, [{ id: 'r1', request: REQUEST, decision: { kind: 'reject' }, source: OUTCOMES.timeout }])
+    assert.equal(clock.pendingTimers(), 0)
+  })
+
+  it('approves on timeout when configured to', () => {
+    const { registry, clock, settlements } = registryOf()
+    registry.open({ id: 'r1', request: REQUEST, countdown: { remainingMs: 1000, action: 'approve', freezeOnInteract: true } })
+    clock.advance(1000)
+    assert.equal(settlements[0].decision.kind, 'approve')
+    assert.equal(settlements[0].source, OUTCOMES.timeout)
+  })
+
+  it('reports the remaining time and stops counting once settled', () => {
+    const { registry, clock } = registryOf()
+    registry.open({ id: 'r1', request: REQUEST, countdown: { remainingMs: 10000, action: 'reject', freezeOnInteract: true } })
+    clock.advance(4000)
+    assert.equal(registry.remaining('r1'), 6000)
+    registry.settle('r1', { kind: 'approve' })
+    assert.equal(registry.remaining('r1'), null)
+  })
+
+  it('has no countdown when the mount configured none', () => {
+    const { registry, clock, settlements } = registryOf()
+    registry.open({ id: 'r1', request: REQUEST, countdown: null })
+    clock.advance(10 ** 7)
+    assert.equal(settlements.length, 0)
+    assert.equal(registry.remaining('r1'), null)
+    assert.equal(clock.pendingTimers(), 0)
+  })
+})
+
+describe('pending: interaction hold', () => {
+  it('freezes the countdown and resumes with the frozen remainder', () => {
+    const { registry, clock, settlements } = registryOf()
+    registry.open({ id: 'r1', request: REQUEST, countdown: { remainingMs: 10000, action: 'reject', freezeOnInteract: true } })
+    clock.advance(4000)
+    assert.deepEqual(registry.hold('r1', true), { ok: true, held: true, expiresAt: 4000 + 300000 })
+    clock.advance(60000)
+    assert.equal(settlements.length, 0)
+    assert.equal(registry.remaining('r1'), 6000)
+    assert.deepEqual(registry.hold('r1', false), { ok: true, held: false })
+    clock.advance(5999)
+    assert.equal(settlements.length, 0)
+    clock.advance(1)
+    assert.equal(settlements.length, 1)
+  })
+
+  it('is idempotent while held', () => {
+    const { registry } = registryOf()
+    registry.open({ id: 'r1', request: REQUEST, countdown: { remainingMs: 10000, action: 'reject', freezeOnInteract: true } })
+    const first = registry.hold('r1', true)
+    assert.deepEqual(registry.hold('r1', true), first)
+  })
+
+  it('releases the hold on its own after the grace window', () => {
+    const { registry, clock, settlements } = registryOf({ holdGraceMs: 1000 })
+    registry.open({ id: 'r1', request: REQUEST, countdown: { remainingMs: 5000, action: 'reject', freezeOnInteract: true } })
+    clock.advance(1000)
+    assert.deepEqual(registry.hold('r1', true), { ok: true, held: true, expiresAt: 2000 })
+    clock.advance(1000)
+    clock.advance(5000)
+    assert.equal(settlements.length, 1)
+  })
+
+  it('ignores a hold the mount did not opt into, or a request without a countdown', () => {
+    const { registry, settlements, clock } = registryOf()
+    registry.open({ id: 'r1', request: REQUEST, countdown: { remainingMs: 1000, action: 'reject', freezeOnInteract: false } })
+    assert.deepEqual(registry.hold('r1', true), { ok: true, held: false })
+    registry.open({ id: 'r2', request: REQUEST, countdown: null })
+    assert.deepEqual(registry.hold('r2', true), { ok: true, held: false })
+    clock.advance(1000)
+    assert.equal(settlements.length, 1)
+    assert.equal(settlements[0].id, 'r1')
+  })
+
+  it('reports unknown and settled identities', () => {
+    const { registry } = registryOf()
+    assert.deepEqual(registry.hold('nope', true), { ok: false, code: ERROR_CODES.unknownRequest })
+    registry.open({ id: 'r1', request: REQUEST, countdown: null })
+    registry.settle('r1', { kind: 'approve' })
+    assert.deepEqual(registry.hold('r1', true), { ok: false, code: ERROR_CODES.alreadySettled })
+  })
+
+  it('drops a hold timer when the request settles', () => {
+    const { registry, clock, settlements } = registryOf({ holdGraceMs: 60000 })
+    registry.open({ id: 'r1', request: REQUEST, countdown: { remainingMs: 60000, action: 'reject', freezeOnInteract: true } })
+    registry.hold('r1', true)
+    assert.equal(clock.pendingTimers(), 1)
+    registry.settle('r1', { kind: 'approve' })
+    assert.equal(clock.pendingTimers(), 0)
+    clock.advance(120000)
+    assert.equal(settlements.length, 1)
+  })
+})
+
+describe('pending: withdrawal', () => {
+  it('cancels through abort and drain', () => {
+    const { registry, settlements, clock } = registryOf()
+    registry.open({ id: 'r1', request: REQUEST, countdown: { remainingMs: 1000, action: 'reject', freezeOnInteract: true } })
+    registry.open({ id: 'r2', request: REQUEST, countdown: null })
+    assert.deepEqual(registry.abort('r2'), { accepted: true })
+    assert.deepEqual(registry.drain(), ['r1'])
+    assert.equal(registry.size(), 0)
+    assert.deepEqual(settlements.map(entry => [entry.id, entry.decision, entry.source]), [
+      ['r2', { kind: 'cancel' }, OUTCOMES.abort],
+      ['r1', { kind: 'cancel' }, OUTCOMES.host],
+    ])
+    clock.advance(10000)
+    assert.equal(settlements.length, 2)
+  })
+
+  it('drains nothing when no request is open', () => {
+    const { registry } = registryOf()
+    assert.deepEqual(registry.drain(), [])
+  })
+})
+
+describe('pending: projected countdown state', () => {
+  it('reports the frozen remainder and the hold while a client holds it', () => {
+    const { registry, clock } = registryOf()
+    registry.open({ id: 'r1', request: REQUEST, countdown: { remainingMs: 30000, action: 'reject', freezeOnInteract: true } })
+    clock.advance(10000)
+    assert.equal(registry.remaining('r1'), 20000)
+    assert.equal(registry.held('r1'), false)
+    registry.hold('r1', true)
+    assert.equal(registry.held('r1'), true)
+    assert.equal(registry.remaining('r1'), 20000, 'a held countdown reads its frozen remainder')
+    registry.hold('r1', false)
+    assert.equal(registry.held('r1'), false)
+    assert.equal(registry.remaining('r1'), 20000)
+  })
+
+  it('reports no countdown and no hold for a request without one', () => {
+    const { registry } = registryOf()
+    registry.open({ id: 'r1', request: REQUEST, countdown: null })
+    assert.equal(registry.remaining('r1'), null)
+    assert.equal(registry.held('r1'), false)
+  })
+})

package/tests/protocol.test.js

@@ -0,0 +1,117 @@
+import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
+
+import {
+  ERROR_CODES, LIMITS, PROTOCOL_VERSION, errorBody, frameHoldAck, frameRequest, frameSettled,
+  frameSnapshot, isDecision, isRecord, okBody, parseUplink, sseChunk, truncate,
+} from '../lib/protocol.js'
+
+describe('protocol: guards', () => {
+  it('accepts plain records only', () => {
+    assert.equal(isRecord({}), true)
+    assert.equal(isRecord([]), false)
+    assert.equal(isRecord(null), false)
+    assert.equal(isRecord('x'), false)
+  })
+
+  it('accepts the three decision kinds', () => {
+    assert.equal(isDecision({ kind: 'approve' }), true)
+    assert.equal(isDecision({ kind: 'reject' }), true)
+    assert.equal(isDecision({ kind: 'reject', feedback: 'no' }), true)
+    assert.equal(isDecision({ kind: 'modify', fields: [{ param: 'a', text: 'b' }] }), true)
+    assert.equal(isDecision({ kind: 'modify', fields: [] }), true)
+    assert.equal(isDecision({ kind: 'cancel' }), false)
+    assert.equal(isDecision({ kind: 'modify', fields: [{ param: 'a' }] }), false)
+    assert.equal(isDecision({ kind: 'reject', feedback: 7 }), false)
+  })
+})
+
+describe('protocol: parseUplink', () => {
+  it('rejects non-objects and missing ids', () => {
+    assert.equal(parseUplink(null).code, ERROR_CODES.badPayload)
+    assert.equal(parseUplink({ type: 'decide', decision: { kind: 'approve' } }).code, ERROR_CODES.badPayload)
+    assert.equal(parseUplink({ id: '', type: 'decide', decision: { kind: 'approve' } }).code, ERROR_CODES.badPayload)
+  })
+
+  it('rejects unknown types and decisions', () => {
+    assert.equal(parseUplink({ id: 'a', type: 'nope' }).code, ERROR_CODES.badPayload)
+    assert.equal(parseUplink({ id: 'a', type: 'decide', decision: { kind: 'maybe' } }).code, ERROR_CODES.badPayload)
+  })
+
+  it('normalizes an approve decision', () => {
+    const parsed = parseUplink({ id: 'a', type: 'decide', decision: { kind: 'approve' } })
+    assert.deepEqual(parsed.value, { type: 'decide', id: 'a', decision: { kind: 'approve' } })
+  })
+
+  it('drops empty reject feedback', () => {
+    assert.deepEqual(parseUplink({ id: 'a', type: 'decide', decision: { kind: 'reject', feedback: '   ' } }).value.decision, { kind: 'reject' })
+    assert.deepEqual(parseUplink({ id: 'a', type: 'decide', decision: { kind: 'reject', feedback: ' 慢 ' } }).value.decision, { kind: 'reject', feedback: '慢' })
+  })
+
+  it('requires at least one changed field for a modify decision', () => {
+    assert.equal(parseUplink({ id: 'a', type: 'decide', decision: { kind: 'modify', fields: [] } }).code, ERROR_CODES.badPayload)
+    const parsed = parseUplink({
+      id: 'a', type: 'decide', decision: { kind: 'modify', fields: [{ param: 'cmd', text: 'ls' }, { param: '', text: 'x' }] },
+    })
+    assert.deepEqual(parsed.value.decision.fields, [{ param: 'cmd', text: 'ls' }])
+  })
+
+  it('normalizes a hold frame', () => {
+    assert.deepEqual(parseUplink({ id: 'a', type: 'hold', held: true }).value, { type: 'hold', id: 'a', held: true })
+    assert.equal(parseUplink({ id: 'a', type: 'hold', held: 'yes' }).code, ERROR_CODES.badPayload)
+  })
+})
+
+describe('protocol: frames', () => {
+  it('stamps the version and keeps optional fields out when absent', () => {
+    assert.deepEqual(frameSnapshot([]), { type: 'snapshot', version: PROTOCOL_VERSION, requests: [] })
+    assert.deepEqual(frameRequest({ id: 'a' }), { type: 'request', version: PROTOCOL_VERSION, request: { id: 'a' } })
+    assert.deepEqual(frameSettled('a', 'user'), { type: 'settled', version: PROTOCOL_VERSION, id: 'a', outcome: 'user' })
+    assert.deepEqual(frameSettled('a', 'user', 'client-1'), { type: 'settled', version: PROTOCOL_VERSION, id: 'a', outcome: 'user', decidedBy: 'client-1' })
+    assert.deepEqual(frameHoldAck('a', true, 12), { type: 'holdAck', version: PROTOCOL_VERSION, id: 'a', held: true, expiresAt: 12 })
+    assert.deepEqual(frameHoldAck('a', false), { type: 'holdAck', version: PROTOCOL_VERSION, id: 'a', held: false })
+  })
+
+  it('serializes one SSE data chunk', () => {
+    assert.equal(sseChunk({ type: 'ping' }), 'data: {"type":"ping"}\n\n')
+  })
+
+  it('wraps route bodies', () => {
+    assert.deepEqual(errorBody('bad-payload', 'nope'), { ok: false, code: 'bad-payload', message: 'nope' })
+    assert.deepEqual(okBody(true), { ok: true, accepted: true })
+  })
+})
+
+describe('protocol: truncate', () => {
+  it('passes short text through', () => {
+    assert.deepEqual(truncate('abc', 5), { text: 'abc', truncated: false })
+  })
+
+  it('marks long text', () => {
+    const cut = truncate('abcdefghij', 4)
+    assert.equal(cut.truncated, true)
+    assert.equal(cut.text.startsWith('abcd'), true)
+    assert.equal(cut.text.includes('已截断，共 10 字'), true)
+  })
+
+  it('exposes sane default limits', () => {
+    assert.equal(LIMITS.maxFieldChars > 0, true)
+    assert.equal(LIMITS.maxBodyBytes > LIMITS.maxFieldChars, true)
+  })
+})
+
+describe('protocol: hold acknowledgement', () => {
+  it('carries the host remainder when it has one', () => {
+    assert.deepEqual(frameHoldAck('a', true, 1200, 45000), {
+      type: 'holdAck', version: PROTOCOL_VERSION, id: 'a', held: true, expiresAt: 1200, remainingMs: 45000,
+    })
+    assert.deepEqual(frameHoldAck('a', false, undefined, 30000), {
+      type: 'holdAck', version: PROTOCOL_VERSION, id: 'a', held: false, remainingMs: 30000,
+    })
+  })
+
+  it('omits a remainder it does not have', () => {
+    assert.deepEqual(frameHoldAck('a', false), { type: 'holdAck', version: PROTOCOL_VERSION, id: 'a', held: false })
+    assert.deepEqual(frameHoldAck('a', false, undefined, null), { type: 'holdAck', version: PROTOCOL_VERSION, id: 'a', held: false })
+  })
+})

package/tests/resolve.test.js

@@ -0,0 +1,162 @@
+import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
+
+import {
+  DEFAULT_OPTIONS, createMatcher, defaultEditable, globToRegExp, matchMount, mountApplies,
+  normalizeMount, normalizeProtectList,
+} from '../lib/resolve.js'
+
+describe('resolve: globToRegExp', () => {
+  it('anchors the pattern and expands the star', () => {
+    const pattern = globToRegExp('mcp__*')
+    assert.equal(pattern.test('mcp__foo'), true)
+    assert.equal(pattern.test('xmcp__foo'), false)
+    assert.equal(pattern.test('mcp__'), true)
+  })
+
+  it('keeps every other character literal', () => {
+    const pattern = globToRegExp('a.b*')
+    assert.equal(pattern.test('a.bX'), true)
+    assert.equal(pattern.test('axbX'), false)
+  })
+})
+
+describe('resolve: createMatcher', () => {
+  it('matches an exact name', () => {
+    assert.equal(createMatcher('bash').test({ name: 'bash' }), true)
+    assert.equal(createMatcher('bash').test({ name: 'bash2' }), false)
+  })
+
+  it('treats a star as a wildcard', () => {
+    assert.equal(createMatcher('mcp__*').test({ name: 'mcp__files' }), true)
+  })
+
+  it('supports a RegExp, a list, and a predicate', () => {
+    assert.equal(createMatcher(/^read/).test({ name: 'read_image' }), true)
+    assert.equal(createMatcher(['a', 'b*']).test({ name: 'banana' }), true)
+    assert.equal(createMatcher(execution => execution.name === 'z').test({ name: 'z' }), true)
+  })
+
+  it('rejects an empty string and an unsupported form', () => {
+    assert.throws(() => createMatcher(''), TypeError)
+    assert.throws(() => createMatcher(7), TypeError)
+  })
+})
+
+describe('resolve: normalizeMount', () => {
+  it('fills every default for a minimal row entry', () => {
+    const { ok, mount } = normalizeMount({ tool: 'bash' }, 'config.protect[0]')
+    assert.equal(ok, true)
+    assert.equal(mount.describe, 'bash')
+    assert.deepEqual(mount.options, {
+      title: undefined,
+      layout: DEFAULT_OPTIONS.layout,
+      labels: [],
+      buttons: {},
+      fields: undefined,
+      diff: undefined,
+      countdown: null,
+      reject: { feedback: false, feedbackPrompt: undefined, requireFeedback: false },
+      modify: { mode: 'revise-request' },
+      whenUnavailable: 'reject',
+      enabled: true,
+      maxFieldChars: DEFAULT_OPTIONS.maxFieldChars,
+    })
+  })
+
+  it('keeps a valid countdown and normalizes its action', () => {
+    const { mount } = normalizeMount({ tool: 'bash', countdown: { seconds: 30 } }, 'src')
+    assert.deepEqual(mount.options.countdown, { seconds: 30, action: 'reject', freezeOnInteract: true })
+    const notify = normalizeMount({ tool: 'bash', countdown: { seconds: 5, action: 'notify', freezeOnInteract: false } }, 'src')
+    assert.deepEqual(notify.mount.options.countdown, { seconds: 5, action: 'notify', freezeOnInteract: false })
+  })
+
+  it('warns and drops an invalid countdown instead of throwing', () => {
+    const { ok, mount, warnings } = normalizeMount({ tool: 'bash', countdown: { seconds: 0 } }, 'src')
+    assert.equal(ok, true)
+    assert.equal(mount.options.countdown, null)
+    assert.equal(warnings.length, 1)
+    assert.match(warnings[0], /countdown.seconds/)
+  })
+
+  it('normalizes field entries and drops invalid ones', () => {
+    const { mount, warnings } = normalizeMount({
+      tool: 'edit',
+      fields: ['file_path', { param: 'content', title: '新内容', render: 'text', editable: true, labels: ['不可撤销'] }, { param: 'x', render: 'nope' }],
+    }, 'src')
+    assert.deepEqual(mount.options.fields, [
+      { param: 'file_path' },
+      { param: 'content', title: '新内容', render: 'text', editable: true, labels: ['不可撤销'] },
+    ])
+    assert.equal(warnings.length, 1)
+    assert.match(warnings[0], /fields\[2\]\.render/)
+  })
+
+  it('reports a bad layout, unavailable policy, and modify mode', () => {
+    const { mount, warnings } = normalizeMount({
+      tool: 'bash', layout: 'grid', whenUnavailable: 'maybe', modify: { mode: 'ignore' }, maxFieldChars: -1, labels: ['ok', 3],
+    }, 'src')
+    assert.equal(mount.options.layout, 'stacked')
+    assert.equal(mount.options.whenUnavailable, 'reject')
+    assert.deepEqual(mount.options.modify, { mode: 'revise-request' })
+    assert.equal(mount.options.maxFieldChars, DEFAULT_OPTIONS.maxFieldChars)
+    assert.deepEqual(mount.options.labels, ['ok'])
+    assert.equal(warnings.length, 3)
+  })
+
+  it('fails without a usable matcher', () => {
+    assert.equal(normalizeMount({}, 'src').ok, false)
+    assert.equal(normalizeMount('bash', 'src').ok, false)
+    assert.equal(normalizeMount({ tool: '' }, 'src').ok, false)
+  })
+
+  it('accepts the API matcher form', () => {
+    const { mount } = normalizeMount({ matcher: /^read/, options: {} }, 'hitl.protect()')
+    assert.equal(mount.describe, String(/^read/))
+  })
+})
+
+describe('resolve: normalizeProtectList', () => {
+  it('keeps valid rows and reports the rest', () => {
+    const { mounts, warnings } = normalizeProtectList([
+      { tool: 'bash' }, { tool: '' }, 'nope', { tool: 'read', countdown: { seconds: -1 } },
+    ])
+    assert.deepEqual(mounts.map(mount => mount.describe), ['bash', 'read'])
+    assert.equal(warnings.length, 3)
+  })
+
+  it('warns when the list itself is malformed', () => {
+    assert.equal(normalizeProtectList({ tool: 'bash' }).warnings.length, 1)
+    assert.deepEqual(normalizeProtectList(undefined), { mounts: [], warnings: [] })
+  })
+})
+
+describe('resolve: match and applicability', () => {
+  it('lets the most recent mount win', () => {
+    const first = normalizeMount({ tool: 'bash', title: 'first' }, 'a').mount
+    const second = normalizeMount({ tool: 'bash', title: 'second' }, 'b').mount
+    assert.equal(matchMount([first, second], { name: 'bash' }).options.title, 'second')
+    assert.equal(matchMount([first], { name: 'other' }), undefined)
+  })
+
+  it('honours enabled as a boolean, a predicate, and a throwing predicate', () => {
+    const base = normalizeMount({ tool: 'bash' }, 'a').mount
+    assert.equal(mountApplies(base, { name: 'bash' }), true)
+    assert.equal(mountApplies({ options: { enabled: false } }, {}), false)
+    assert.equal(mountApplies({ options: { enabled: execution => execution.name === 'bash' } }, { name: 'bash' }), true)
+    assert.equal(mountApplies({ options: { enabled: execution => execution.name === 'bash' } }, { name: 'zsh' }), false)
+    assert.equal(mountApplies({ options: { enabled: () => { throw new Error('boom') } } }, {}), false)
+    assert.equal(mountApplies({ options: { enabled: 'yes' } }, {}), false)
+    assert.equal(mountApplies({ options: {} }, {}), true)
+  })
+})
+
+describe('resolve: defaultEditable', () => {
+  it('makes text and markdown editable, everything else read-only', () => {
+    assert.equal(defaultEditable('markdown'), true)
+    assert.equal(defaultEditable('text'), true)
+    assert.equal(defaultEditable('diff'), false)
+    assert.equal(defaultEditable('json'), false)
+    assert.equal(defaultEditable('hidden'), false)
+  })
+})