weir-harness 1.2.3 → 2.1.0

package/src/edit-lock/remote.js

@@ -1,362 +0,0 @@
-import { createHash, randomUUID } from 'node:crypto'
-import { lstatSync, realpathSync, unlinkSync } from 'node:fs'
-import { createConnection, createServer } from 'node:net'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { asBindingFailure, bindingGuidance, bindingRefusal } from './binding-guidance.js'
-import { createEditLockPeer } from './peer.js'
-import { serveEditLockPeer } from './peer-transport.js'
-import { createEditLockPeerClient } from './peer-client.js'
-
-/** Deterministic per-user endpoint for one canonical authority directory. On
- * POSIX hosts the OS temp directory is user-private and the endpoint is a
- * domain-socket file; on Windows it is a named pipe (a kernel object with no
- * filesystem node, so there is no stale-node sweep and no 100-byte path
- * budget — only the 256-char pipe-name limit) whose name carries no
- * backslashes beyond the \\.\pipe\ prefix (verified on Node v24). Any
- * same-user process that can reach the endpoint is inside the cooperative
- * trust boundary, not attested.
- * @param {string} directory @param {string} [platform] */
-export function endpointFor(directory, platform = process.platform) {
-  const authority = realpathSync.native(directory)
-  const hash = createHash('sha256').update(authority).digest('hex').slice(0, 24)
-  if (platform === 'win32') return `\\\\.\\pipe\\weir-edit-lock-${hash}`
-  const path = join(tmpdir(), `weir-edit-lock-${hash}.sock`)
-  if (Buffer.byteLength(path) > 100) throw new Error(`edit lock endpoint path too long: ${path}`)
-  return path
-}
-
-/** True for Windows named-pipe endpoints: no filesystem node exists, so the
- * stale-socket sweep and the close-time unlink are POSIX-only concerns.
- * @param {string} endpoint */
-const namedPipe = endpoint => endpoint.startsWith('\\\\.\\pipe\\') || endpoint.startsWith('\\\\?\\pipe\\')
-
-/** Channel-open arbitration for one endpoint (duplicate-binding recovery,
- * design D1/D2/D4). One sessionId has at most one registered channel at any
- * moment:
- *
- * - a prior binding whose socket is PROVEN dead (synchronous state bits only:
- *   `destroyed`, `closed` or `errored` — never an active probe) is reclaimed
- *   through the SAME disconnect path a processed EOF takes (revoke + forget;
- *   no lock is ever released), then the new open proceeds;
- * - a live-looking same-process holder may also be reclaimed when its nonce
- *   is host-attested stale; serving, cross-process and unknown holders refuse;
- * - with no prior channel binding, a refusal from `lifecycle.start` itself
- *   (a local agent or another mount generation holds the session) passes
- *   through: local runtime identities are adjudicated only by the lifecycle.
- *
- * Opens of one sessionId are serialized through a per-session promise queue,
- * because the reclaim-check-register sequence awaits; different sessionIds
- * stay fully concurrent. Exported for the unit tests; production wiring is
- * the endpoint below.
- * @param {(sessionId: string, nonce: string) => 'serving'|'stale'|'unknown'} [attest] */
-export function createChannelBindingArbitration(attest = () => 'unknown') {
-  /** @typedef {{destroyed?: boolean, closed?: boolean, errored?: unknown}} ChannelSocket */
-  /** @typedef {{disconnect: () => Promise<unknown>}} ChannelPeer */
-  /** @type {Map<string, {socket: ChannelSocket, peer: ChannelPeer, nonce?: string, pid?: number}>} */
-  const bound = new Map()
-  /** @type {Map<string, Promise<unknown>>} */
-  const opening = new Map()
-  /** @param {string} sessionId @param {{pid?: number, nonce?: string}} holder */
-  function verdict(sessionId, holder) {
-    if (holder.pid !== process.pid || !holder.nonce) return 'unknown'
-    try { return attest(sessionId, holder.nonce) } catch { return 'unknown' }
-  }
-  /** @param {string} sessionId
-   * @param {ChannelSocket} socket the NEW connection's socket
-   * @param {() => Promise<{peer: ChannelPeer}>} bind establish the channel
-   * (create the peer and start the lifecycle); its result is returned verbatim
-   * @param {{nonce?: string, pid?: number}} [token] additive optional client identity
-   * @param {() => void} [validate]
-   * @returns {Promise<any>} */
-  function open(sessionId, socket, bind, token = {}, validate = () => {}) {
-    return enqueue(sessionId, async () => {
-      validate()
-      await reclaim(sessionId)
-      validate()
-      const established = await bind()
-      bound.set(sessionId, { socket, peer: established.peer, nonce: token.nonce, pid: token.pid })
-      return established
-    })
-  }
-  /** Local and remote startup share this queue; the trusted callback rechecks
-   * exact claimant identity after the durable revoke barrier.
-   * @param {string} sessionId @param {(reclaimed: boolean) => Promise<any>} bind @param {() => void} [validate] */
-  function openLocal(sessionId, bind, validate = () => {}) {
-    return enqueue(sessionId, async () => { validate(); const reclaimed = await reclaim(sessionId); validate(); return bind(reclaimed) })
-  }
-  /** @param {string} sessionId @param {() => Promise<any>} step */
-  function enqueue(sessionId, step) {
-    const queued = opening.get(sessionId) ?? Promise.resolve()
-    const run = queued.then(step, step)
-    opening.set(sessionId, run)
-    const settled = () => { if (opening.get(sessionId) === run) opening.delete(sessionId) }
-    run.then(settled, settled)
-    return run
-  }
-  /** @param {string} sessionId */
-  async function reclaim(sessionId) {
-    const prior = bound.get(sessionId)
-    if (prior) {
-      const dead = prior.socket.destroyed === true || prior.socket.closed === true || prior.socket.errored != null
-      const attestation = dead ? 'unknown' : verdict(sessionId, prior)
-      const refusal = () => bindingRefusal(prior.pid, attestation)
-      if (!dead && attestation !== 'stale') throw refusal()
-      try { await prior.peer.disconnect() } catch {
-        // Reclaim outcome unknown: stay fail-closed and KEEP the mapping, so
-        // the next open retries the reclaim instead of wedging behind a
-        // lifecycle-level refusal.
-        throw bindingRefusal(prior.pid, attestation, true)
-      }
-      if (bound.get(sessionId) === prior) bound.delete(sessionId)
-    }
-    return prior !== undefined
-  }
-  /** Index hygiene on transport close: drop the entry only while it still
-   * names THIS connection's socket — a reclaimed binding must never be removed
-   * by the late close of the dead socket it replaced. Await the same cached
-   * disconnect result as the transport before forgetting its mapping.
-   * @param {string} sessionId @param {ChannelSocket} socket */
-  async function release(sessionId, socket) {
-    const prior = bound.get(sessionId)
-    if (!prior || prior.socket !== socket) return
-    // EOF and attested reclaim share the durable disconnect result. A failed
-    // EOF must not erase the retryable mapping either.
-    try { await prior.peer.disconnect() } catch { return }
-    if (bound.get(sessionId) === prior) bound.delete(sessionId)
-  }
-  return Object.freeze({ open, openLocal, release,
-    bindings() {
-      return [...bound].map(([sessionId, holder]) => {
-        const attestation = verdict(sessionId, holder)
-        return { sessionId, present: true, holderPid: holder.pid ?? null, attestable: attestation !== 'unknown', attestation }
-      })
-    },
-  })
-}
-
-/** Publisher side: one session channel per connection. The first frame must be
- * `open {sessionId}`; the channel agent is fixed afterwards and EOF revokes it.
- * Call only while holding the publisher reservation (stale socket removal).
- * @param {ReturnType<typeof import('./lifecycle.js').createEditLockLifecycle>} lifecycle
- * @param {string} endpoint
- * @param {WeakMap<object, (event: unknown) => void>} sinks remote agent → notice sink
- * @param {(sessionId: string, nonce: string) => 'serving'|'stale'|'unknown'} [attest]
- * @param {(agent: any, requireProof: boolean) => boolean} [isCurrentLocal] */
-export async function serveEditLockEndpoint(lifecycle, endpoint, sinks, attest, isCurrentLocal) {
-  if (!namedPipe(endpoint)) {
-    try {
-      if (!lstatSync(endpoint).isSocket()) throw new Error(`unexpected node at edit lock endpoint ${endpoint}`)
-      unlinkSync(endpoint)
-    } catch (error) { if (/** @type {any} */ (error)?.code !== 'ENOENT') throw error }
-  }
-  /** @type {Set<{close: () => Promise<unknown>}>} */
-  const channels = new Set()
-  let closed = false
-  const arbitration = createChannelBindingArbitration(attest)
-  const server = createServer(socket => {
-    if (closed) { socket.destroy(); return }
-    /** @type {ReturnType<typeof createEditLockPeer> | undefined} */
-    let inner
-    /** @type {string | undefined} */
-    let openedSessionId
-    const router = {
-      /** @param {any} message */
-      async receive(message) {
-        if (inner) return inner.receive(message)
-        const sessionId = message?.request?.sessionId
-        if (message?.kind !== 'open' || typeof sessionId !== 'string' || !sessionId || sessionId.length > 256) throw new Error('channel must open a session first')
-        openedSessionId = sessionId
-        try {
-          const opened = await arbitration.open(sessionId, socket, async () => {
-            const agent = Object.freeze({ id: sessionId, remote: true })
-            sinks.set(agent, event => transport.notify(event))
-            inner = createEditLockPeer(lifecycle, agent)
-            // A retry open is a trusted driving ingress (change
-            // edit-lock-binding-transfer): when the ordinary start is refused by
-            // a duplicate LOCAL holder, the transfer admission re-adjudicates the
-            // holder's idleness publisher-side. start() runs first and refuses
-            // without side effects, so a non-transferable refusal keeps its
-            // original classification and is evaluated exactly once per caller.
-            if (message.request.retry === true && typeof lifecycle.transferStart === 'function') {
-              try {
-                const state = await lifecycle.start(agent)
-                return { peer: inner, state }
-              } catch (error) {
-                if (/** @type {any} */ (error)?.bindingFailure?.code !== 'binding-duplicate') throw error
-                const state = await lifecycle.transferStart(agent)
-                return { peer: inner, state }
-              }
-            }
-            const state = await lifecycle.start(agent)
-            return { peer: inner, state }
-          }, { nonce: typeof message.request.nonce === 'string' && message.request.nonce.length <= 256 ? message.request.nonce : undefined,
-            pid: Number.isSafeInteger(message.request.pid) && message.request.pid > 0 ? message.request.pid : undefined },
-            () => { if (message.request.retry === true) lifecycle.assertStartable({ id: sessionId, remote: true }) })
-          return { state: opened.state }
-        } catch (error) {
-          const failure = /** @type {any} */ (error)?.bindingFailure
-          if (message.request.bindingFailures === true && failure?.code === 'binding-duplicate') return { state: 'unavailable', bindingFailure: failure, reason: String(/** @type {any} */ (error).message) }
-          throw error
-        }
-      },
-      disconnect() { return inner ? inner.disconnect() : Promise.resolve() },
-    }
-    const transport = serveEditLockPeer(socket, router)
-    channels.add(transport)
-    socket.once('close', () => {
-      channels.delete(transport)
-      if (openedSessionId !== undefined) arbitration.release(openedSessionId, socket)
-    })
-  })
-  await new Promise((resolve, reject) => {
-    server.once('error', reject)
-    server.listen(endpoint, () => { server.off('error', reject); resolve(undefined) })
-  })
-  return Object.freeze({
-    bindings: arbitration.bindings,
-    /** @param {any} agent @param {boolean} [retry] @param {boolean} [transfer]
-     * transfer: the claimant arrives through a driving ingress whose registry
-     * identity is the defect being repaired — the lifecycle transfer admission
-     * decides, and the currency proof relaxes accordingly (isCurrentLocal). */
-    startLocal(agent, retry = false, transfer = false) {
-      return arbitration.openLocal(agent.id, async reclaimed => {
-        const current = () => {
-          try { return !closed && (isCurrentLocal ? isCurrentLocal(agent, reclaimed || retry, transfer) : !(reclaimed || retry)) } catch { return false }
-        }
-        if (!current()) throw new Error('local edit binding claimant is no longer current')
-        const state = transfer && typeof lifecycle.transferStart === 'function' ? await lifecycle.transferStart(agent) : await lifecycle.start(agent)
-        if (!current()) {
-          // A stopped entry still has subtractive cleanup authority. Forget it
-          // only after durable revocation; never dispose (which releases locks).
-          await lifecycle.forget(agent)
-          throw new Error('local edit binding claimant is no longer current')
-        }
-        return state
-      }, () => { if (retry) lifecycle.assertStartable(agent) })
-    },
-    /** Seal admission, then revoke every channel; await before lifecycle.close. */
-    async close() {
-      closed = true
-      await new Promise(resolve => server.close(() => resolve(undefined)))
-      const results = await Promise.allSettled([...channels].map(channel => channel.close()))
-      if (!namedPipe(endpoint)) {
-        try { unlinkSync(endpoint) } catch { /* already gone */ }
-      }
-      const errors = results.filter(result => result.status === 'rejected').map(result => /** @type {any} */ (result).reason)
-      if (errors.length) throw new AggregateError(errors, 'edit lock endpoint revocation failed')
-    },
-  })
-}
-
-/** Client side for a host whose publisher reservation is held elsewhere. Each
- * agent gets its own session channel; a closed channel is never silently
- * replaced mid-call. Outcomes of interrupted calls are UNKNOWN by contract.
- * @param {string} endpoint
- * @param {{onNotice: (agent: object, event: any) => void, unreachableHint?: string, onChannelOpen?: (nonce: string, agent: object, sessionId: string) => (() => void)}} hooks */
-export function createRemoteEditLockDomain(endpoint, hooks) {
-  /** @typedef {{client: ReturnType<typeof createEditLockPeerClient>, state: string, closed: boolean, ready: Promise<void>}} Channel */
-  /** @type {WeakMap<object, Channel>} */
-  const channels = new WeakMap()
-  /** @type {Set<Channel>} */
-  const all = new Set()
-  const never = new AbortController().signal
-  let closed = false
-  /** Failure classes are split by WHERE the open failed, never by guessing at
-   * message text (design D3): a transport that never came up — or an open
-   * request that never got an answer — is an unreachable publisher and carries
-   * the reservation hint; an open the publisher answered and refused is a live
-   * publisher rejecting the binding, surfaced with its own guidance after the
-   * duplicate-binding retry budget runs out. Only that answered refusal is
-   * retried: the publisher may not yet have processed (or even seen) the
-   * earlier channel's death. Never a call.
-   * @param {any} agent @param {boolean} [retry] @returns {Promise<Channel>} */
-  async function channelFor(agent, retry = false) {
-    for (let attempt = 0; ; attempt++) {
-      try { return await openChannel(agent, retry) } catch (error) {
-        if (/** @type {any} */ (error)?.answeredRefusal !== true) throw error
-        // The retry budget classifies on the STRUCTURED refusal field, never on
-        // the display text (change edit-lock-deepening, design D2): only an
-        // answered, publisher-classified duplicate binding is retried — the
-        // publisher may not yet have processed the earlier channel's death.
-        if (!retry && /** @type {any} */ (error)?.bindingFailure?.code === 'binding-duplicate' && attempt < 20) {
-          await new Promise(resolve => setTimeout(resolve, 50))
-          continue
-        }
-        const reason = String(/** @type {any} */ (error)?.message ?? error)
-        const guidance = bindingGuidance(agent.id, /** @type {any} */ (error)?.bindingFailure)
-        throw Object.assign(new Error(`edit lock duplicate session binding: ${guidance} (publisher answered: ${reason})`), { bindingFailure: /** @type {any} */ (error)?.bindingFailure })
-      }
-    }
-  }
-  /** @param {any} agent @param {boolean} retry @returns {Promise<Channel>} */
-  async function openChannel(agent, retry) {
-    if (closed) throw new Error('edit lock client closed')
-    const existing = channels.get(agent)
-    if (existing && !existing.closed) { await existing.ready; return existing }
-    const nonce = randomUUID()
-    const unregister = hooks.onChannelOpen?.(nonce, agent, agent.id) ?? (() => {})
-    let socket
-    try { socket = createConnection(endpoint) } catch (error) { unregister(); throw error }
-    /** @type {Channel} */
-    const channel = /** @type {any} */ ({ state: 'starting', closed: false })
-    channel.client = createEditLockPeerClient(socket, {
-      onEvent: event => hooks.onNotice(agent, event),
-      onClose: () => { unregister(); channel.closed = true; channel.state = 'stopped'; all.delete(channel) },
-    })
-    channels.set(agent, channel)
-    all.add(channel)
-    /** The publisher genuinely did not answer. @param {unknown} cause */
-    const unreachable = cause => new Error(`edit lock publisher unreachable at ${endpoint}: ${/** @type {any} */ (cause)?.message ?? cause}${hooks.unreachableHint ? `. ${hooks.unreachableHint}` : ''}`)
-    channel.ready = (async () => {
-      try {
-        await new Promise((resolve, reject) => {
-          socket.once('connect', resolve)
-          socket.once('error', reject)
-        })
-      } catch (error) {
-        // The transport never came up: the publisher process is not answering.
-        throw unreachable(error)
-      }
-      let opened
-      try {
-        opened = await channel.client.request('open', 'open', { sessionId: agent.id, nonce, pid: process.pid, bindingFailures: true, retry }, never)
-        // The answered refusal's structured field is validated on receipt;
-        // only the exact minted shape becomes decision input.
-        const refused = opened?.state === 'unavailable' ? asBindingFailure(opened.bindingFailure) : undefined
-        if (refused) throw Object.assign(new Error(opened.reason), { bindingFailure: refused })
-      } catch (error) {
-        const message = String(/** @type {any} */ (error)?.message ?? error)
-        // No answer ever arrived — the channel died mid-open or the request
-        // was never dispatched: the same failure class as a connect error.
-        if (message.startsWith('edit publication outcome UNKNOWN:') || message.startsWith('edit peer unavailable')) throw unreachable(error)
-        // The publisher answered and refused the open. channelFor owns the
-        // retry budget and the final message for answered refusals.
-        throw Object.assign(error instanceof Error ? error : new Error(message), { answeredRefusal: true })
-      }
-      if (!channel.closed) channel.state = opened.state
-    })()
-    try { await channel.ready } catch (error) {
-      channel.client.close()
-      throw error
-    }
-    return channel
-  }
-  /** @param {object} agent @param {string} kind @param {unknown} [request] @param {AbortSignal} [signal] @param {string} [callId] */
-  async function call(agent, kind, request, signal, callId) {
-    const channel = await channelFor(agent)
-    return channel.client.request(kind, callId ?? `${kind}:${randomUUID()}`, request ?? {}, signal ?? never)
-  }
-  return Object.freeze({
-    channelFor,
-    call,
-    /** @param {object} agent */
-    state(agent) { const channel = channels.get(agent); return channel && !channel.closed ? channel.state : 'stopped' },
-    /** @param {object} agent @param {string} state */
-    setState(agent, state) { const channel = channels.get(agent); if (channel && !channel.closed) channel.state = state },
-    /** Conservative local revocation: the publisher revokes on EOF.
-     * @param {object} agent */
-    drop(agent) { channels.get(agent)?.client.close() },
-    close() { closed = true; for (const channel of [...all]) channel.client.close() },
-  })
-}

package/src/edit-lock/request-binding.js

@@ -1,42 +0,0 @@
-import { createHash } from 'node:crypto'
-import { isAbsolute } from 'node:path'
-import { canonicalRequestData } from './request-data.js'
-import { validateBinding } from './operation-history.js'
-
-/** @param {string} value */
-const digest = value => createHash('sha256').update(Buffer.from(value, 'utf8')).digest('hex')
-
-/** Compute historical binding only; never grants publication authority.
- * Caller supplies trusted, fully resolved policy and observed target, not model
- * assertions. Policy authorization and topology checks remain manager duties.
- * @param {{tool: 'write'|'hash_edit'|'lsp_rename', filePath: string, cwd: string, args: unknown, content: string,
- * effectivePolicy: unknown, target: import('./operation-history.js').Target}} input
- * @returns {import('./operation-history.js').Binding} */
-export function bindRequest(input) {
-  // Validate before property reads/copying, so ordinary getters never execute.
-  const data = JSON.parse(canonicalRequestData(input))
-  if (typeof data.content !== 'string') throw new Error('invalid content')
-  if (!['write', 'hash_edit', 'lsp_rename'].includes(data.tool)) throw new Error('invalid tool')
-  if (typeof data.filePath !== 'string' || !data.filePath || data.filePath.includes('\0') ||
-      typeof data.cwd !== 'string' || !isAbsolute(data.cwd) || data.cwd.includes('\0')) throw new Error('invalid request path')
-  if (!data.target || !['create', 'update'].includes(data.target.kind)) throw new Error('invalid target')
-  if (data.target.kind === 'create' && data.tool !== 'write') throw new Error('creation requires write')
-  if (!data.effectivePolicy || typeof data.effectivePolicy !== 'object' || Array.isArray(data.effectivePolicy)) throw new Error('invalid effective policy')
-  const argsDigest = digest(canonicalRequestData(data.args))
-  const payloadDigest = digest(data.content)
-  const requestDigest = digest(canonicalRequestData({ version: 1, tool: data.tool, method: 'writeText',
-    filePath: data.filePath, cwd: data.cwd, expected: data.target.policy, effectivePolicy: data.effectivePolicy,
-    argsDigest, payloadDigest, target: data.target }))
-  /** @param {any} value */
-  function freeze(value) {
-    if (value && typeof value === 'object') {
-      for (const child of Object.values(value)) freeze(child)
-      Object.freeze(value)
-    }
-    return value
-  }
-  const binding = { tool: data.tool, filePath: data.filePath, cwd: data.cwd,
-    argsDigest, payloadDigest, requestDigest, target: data.target }
-  validateBinding(binding)
-  return freeze(binding)
-}

package/src/edit-lock/request-data.js

@@ -1,40 +0,0 @@
-/** Strict canonical JSON for trusted adapter input, before hashing or copying.
- * Rejects lossy representations rather than silently dropping request fields.
- * This is not a sandbox for hostile executable objects (including Proxies).
- * @param {unknown} value @returns {string} */
-export function canonicalRequestData(value) {
-  const ancestors = new Set()
-  /** @param {unknown} node @returns {string} */
-  function encode(node) {
-    if (node === null || typeof node === 'string' || typeof node === 'boolean') return JSON.stringify(node)
-    if (typeof node === 'number' && Number.isFinite(node) && !Object.is(node, -0)) return JSON.stringify(node)
-    if (typeof node !== 'object' || node === null || ancestors.has(node)) throw new Error('invalid request data')
-    const array = Array.isArray(node)
-    const prototype = Object.getPrototypeOf(node)
-    if (array ? prototype !== Array.prototype : prototype !== Object.prototype && prototype !== null) throw new Error('invalid request data prototype')
-    const descriptors = Object.getOwnPropertyDescriptors(node)
-    const keys = Reflect.ownKeys(descriptors)
-    for (const key of keys) {
-      if (typeof key !== 'string') throw new Error('invalid request data symbol')
-      const descriptor = descriptors[key]
-      if (!('value' in descriptor) || (!descriptor.enumerable && !(array && key === 'length'))) throw new Error('invalid request data descriptor')
-    }
-    ancestors.add(node)
-    try {
-      if (array) {
-        if (keys.length !== node.length + 1) throw new Error('invalid request data array')
-        const items = []
-        for (let index = 0; index < node.length; index++) {
-          const descriptor = descriptors[String(index)]
-          if (!descriptor) throw new Error('invalid request data sparse array')
-          items.push(encode(descriptor.value))
-        }
-        return `[${items.join(',')}]`
-      }
-      return `{${Object.keys(descriptors).sort().map(key => `${JSON.stringify(key)}:${encode(descriptors[key].value)}`).join(',')}}`
-    } finally {
-      ancestors.delete(node)
-    }
-  }
-  return encode(value)
-}