@recombine-ai/bosun 0.16.2 → 0.17.1

package/src/lib/git-mode/GitControlsButton.svelte

@@ -0,0 +1,96 @@
+<script lang="ts">
+	import Button from '$lib/components/Button.svelte'
+	import { getGitModeContext } from './git-mode-context'
+
+	const gitMode = getGitModeContext()
+	const manualAction = $derived(gitMode.manualAction())
+	const busy = $derived(
+		manualAction !== null ||
+			gitMode.state.phase !== 'idle' ||
+			gitMode.isWritePaused() ||
+			gitMode.isActivationStarting()
+	)
+	const changeActionDisabled = $derived(!gitMode.state.hasChanges || busy)
+	const prepareDisabled = $derived(
+		gitMode.state.hasChanges || !gitMode.state.canPrepareRelease || busy
+	)
+	const changeActionDisabledMessage = $derived(
+		!gitMode.state.hasChanges
+			? 'No changes to save or discard'
+			: busy
+				? 'A Git operation is in progress'
+				: ''
+	)
+	const prepareDisabledMessage = $derived(
+		busy
+			? 'A Git operation is in progress'
+			: gitMode.state.hasChanges
+				? 'Save or discard changes before preparing for release'
+				: !gitMode.state.canPrepareRelease
+					? 'No changes to prepare for release'
+					: ''
+	)
+</script>
+
+{#if gitMode.state.enabled}
+	<div class="flex min-w-0 flex-wrap items-center justify-end gap-1">
+		<div class="group relative inline-flex" tabindex={changeActionDisabled ? 0 : undefined}>
+			<Button
+				variant="outlined"
+				size="small"
+				disabled={changeActionDisabled}
+				onclick={gitMode.openDiscardDialog}
+				class="whitespace-nowrap !px-2.5 !py-1 !text-sm"
+			>
+				{manualAction === 'discard' ? 'Discarding...' : 'Discard'}
+			</Button>
+			{#if changeActionDisabledMessage}
+				<div
+					role="tooltip"
+					class="pointer-events-none absolute right-0 top-full z-40 mt-2 hidden w-max max-w-64 rounded-md border border-rc-gray-600 bg-rc-gray-800 px-3 py-2 text-xs font-normal text-rc-gray-100 shadow-xl group-hover:block group-focus:block"
+				>
+					{changeActionDisabledMessage}
+				</div>
+			{/if}
+		</div>
+
+		<div class="group relative inline-flex" tabindex={changeActionDisabled ? 0 : undefined}>
+			<Button
+				variant="secondary"
+				size="small"
+				disabled={changeActionDisabled}
+				onclick={gitMode.openSaveDialog}
+				class="whitespace-nowrap !px-2.5 !py-1 !text-sm"
+			>
+				{manualAction === 'save' ? 'Saving...' : 'Save'}
+			</Button>
+			{#if changeActionDisabledMessage}
+				<div
+					role="tooltip"
+					class="pointer-events-none absolute right-0 top-full z-40 mt-2 hidden w-max max-w-64 rounded-md border border-rc-gray-600 bg-rc-gray-800 px-3 py-2 text-xs font-normal text-rc-gray-100 shadow-xl group-hover:block group-focus:block"
+				>
+					{changeActionDisabledMessage}
+				</div>
+			{/if}
+		</div>
+
+		<div class="group relative inline-flex" tabindex={prepareDisabled ? 0 : undefined}>
+			<Button
+				size="small"
+				disabled={prepareDisabled}
+				onclick={gitMode.prepareRelease}
+				class="whitespace-nowrap !px-2.5 !py-1 !text-sm"
+			>
+				{manualAction === 'prepare-release' ? 'Preparing...' : 'Prepare for release'}
+			</Button>
+			{#if prepareDisabledMessage}
+				<div
+					role="tooltip"
+					class="pointer-events-none absolute right-0 top-full z-40 mt-2 hidden w-max max-w-64 rounded-md border border-rc-gray-600 bg-rc-gray-800 px-3 py-2 text-xs font-normal text-rc-gray-100 shadow-xl group-hover:block group-focus:block"
+				>
+					{prepareDisabledMessage}
+				</div>
+			{/if}
+		</div>
+	</div>
+{/if}

package/src/lib/git-mode/client-admission.spec.ts

@@ -0,0 +1,304 @@
+import type { Operation, TRPCLink } from '@trpc/client'
+import { observable } from '@trpc/server/observable'
+import { describe, expect, it, vi } from 'vitest'
+
+import {
+	GIT_FLUSH_OPERATION_CONTEXT_KEY,
+	GitModeMutationBlockedError,
+	RepositoryClientAdmission,
+	isGitModeMutationBlockedError,
+	repositoryAdmissionLink
+} from './client-admission'
+import { GIT_MODE_USAGE_BLOCKED_MESSAGE } from './errors'
+
+type Envelope = { result: { type: 'data'; data: string } }
+
+function operation(
+	type: Operation['type'],
+	path: string,
+	context: Record<string, unknown> = {},
+	signal: AbortSignal | null = null
+): Operation {
+	return { id: 1, type, path, context, input: undefined, signal }
+}
+
+function execute(
+	admission: RepositoryClientAdmission,
+	op: Operation,
+	next: ReturnType<TRPCLink<any>> extends (options: infer Options) => unknown
+		? Options extends { next: infer Next }
+			? Next
+			: never
+		: never
+): Promise<Envelope> {
+	const link = repositoryAdmissionLink<any>(admission)({})
+	const result = link({ op, next } as never)
+	return new Promise((resolve, reject) => {
+		result.subscribe({
+			next: (value) => resolve(value as Envelope),
+			error: reject
+		})
+	})
+}
+
+function successfulNext(calls: string[]) {
+	return ((op: Operation) =>
+		observable<Envelope>((observer) => {
+			calls.push(op.path)
+			observer.next({ result: { type: 'data', data: op.path } })
+			observer.complete()
+		})) as any
+}
+
+describe('RepositoryClientAdmission link', () => {
+	it('allows Git control operations while initial admission is unknown', async () => {
+		const admission = new RepositoryClientAdmission()
+		const calls: string[] = []
+
+		await expect(
+			execute(admission, operation('mutation', 'gitMode.status'), successfulNext(calls))
+		).resolves.toMatchObject({ result: { data: 'gitMode.status' } })
+		expect(calls).toEqual(['gitMode.status'])
+	})
+
+	it('defers queries until admission opens', async () => {
+		const admission = new RepositoryClientAdmission()
+		const calls: string[] = []
+		const pending = execute(admission, operation('query', 'agents.catalog'), successfulNext(calls))
+
+		await Promise.resolve()
+		expect(calls).toEqual([])
+		admission.setState({ mode: 'open', flushOperationId: null })
+
+		await expect(pending).resolves.toMatchObject({ result: { data: 'agents.catalog' } })
+		expect(calls).toEqual(['agents.catalog'])
+	})
+
+	it('rechecks admission before dispatching a query whose open waiter resolved', async () => {
+		const admission = new RepositoryClientAdmission()
+		admission.setState({ mode: 'locked', flushOperationId: null })
+		const calls: string[] = []
+		const pending = execute(admission, operation('query', 'agents.catalog'), successfulNext(calls))
+
+		await Promise.resolve()
+		admission.setState({ mode: 'open', flushOperationId: null })
+		admission.setState({ mode: 'locked', flushOperationId: null })
+		await Promise.resolve()
+		expect(calls).toEqual([])
+
+		admission.setState({ mode: 'open', flushOperationId: null })
+		await expect(pending).resolves.toMatchObject({ result: { data: 'agents.catalog' } })
+		expect(calls).toEqual(['agents.catalog'])
+	})
+
+	it('allows an admitted mutation to complete after admission locks', async () => {
+		const admission = new RepositoryClientAdmission()
+		admission.setState({ mode: 'open', flushOperationId: null })
+		const calls: string[] = []
+		let complete!: () => void
+		const next = ((op: Operation) =>
+			observable<Envelope>((observer) => {
+				calls.push(op.path)
+				complete = () => {
+					observer.next({ result: { type: 'data', data: op.path } })
+					observer.complete()
+				}
+			})) as any
+
+		const pending = execute(admission, operation('mutation', 'agents.suggestTestFix'), next)
+		await vi.waitFor(() => expect(calls).toEqual(['agents.suggestTestFix']))
+
+		admission.setState({ mode: 'locked', flushOperationId: null })
+		complete()
+
+		await expect(pending).resolves.toMatchObject({ result: { data: 'agents.suggestTestFix' } })
+		expect(calls).toEqual(['agents.suggestTestFix'])
+	})
+
+	it('blocks and taints a mutation without calling the transport', async () => {
+		const admission = new RepositoryClientAdmission()
+		admission.setState({ mode: 'locked', flushOperationId: null })
+		const calls: string[] = []
+		const blocked = vi.fn()
+		admission.onBlockedMutation(blocked)
+
+		await expect(
+			execute(admission, operation('mutation', 'tests.patchTest'), successfulNext(calls))
+		).rejects.toSatisfy(isGitModeMutationBlockedError)
+		expect(calls).toEqual([])
+		expect(admission.isTainted()).toBe(true)
+		expect(blocked).toHaveBeenCalledWith('tests.patchTest')
+	})
+
+	it('notifies a listener registered after the tab was tainted', () => {
+		const admission = new RepositoryClientAdmission()
+		admission.blockMutation('tests.patchTest')
+		const blocked = vi.fn()
+
+		admission.onBlockedMutation(blocked)
+
+		expect(blocked).toHaveBeenCalledWith('tests.patchTest')
+	})
+
+	it('admits only the active flush token while quiescing', async () => {
+		const admission = new RepositoryClientAdmission()
+		admission.setState({ mode: 'quiescing', flushOperationId: 'operation-1' })
+		const calls: string[] = []
+
+		await expect(
+			execute(
+				admission,
+				operation('mutation', 'agents.savePrompt', {
+					[GIT_FLUSH_OPERATION_CONTEXT_KEY]: 'operation-1'
+				}),
+				successfulNext(calls)
+			)
+		).resolves.toMatchObject({ result: { data: 'agents.savePrompt' } })
+		await expect(
+			execute(
+				admission,
+				operation('mutation', 'regionConfig.save', {
+					[GIT_FLUSH_OPERATION_CONTEXT_KEY]: 'operation-old'
+				}),
+				successfulNext(calls)
+			)
+		).rejects.toBeInstanceOf(Error)
+		expect(calls).toEqual(['agents.savePrompt'])
+	})
+
+	it('keeps deferring a repeatedly server-blocked query until admission reopens successfully', async () => {
+		const admission = new RepositoryClientAdmission()
+		admission.setState({ mode: 'open', flushOperationId: null })
+		let attempts = 0
+		const next = (() =>
+			observable<Envelope>((observer) => {
+				attempts += 1
+				if (attempts <= 2) observer.error(new Error(GIT_MODE_USAGE_BLOCKED_MESSAGE))
+				else {
+					observer.next({ result: { type: 'data', data: 'recovered' } })
+					observer.complete()
+				}
+			})) as any
+
+		const pending = execute(admission, operation('query', 'agents.catalog'), next)
+		await Promise.resolve()
+		expect(admission.getState().mode).toBe('locked')
+		expect(attempts).toBe(1)
+
+		admission.setState({ mode: 'open', flushOperationId: null })
+		await vi.waitFor(() => expect(attempts).toBe(2))
+		expect(admission.getState().mode).toBe('locked')
+
+		admission.setState({ mode: 'open', flushOperationId: null })
+		await expect(pending).resolves.toMatchObject({ result: { data: 'recovered' } })
+		expect(attempts).toBe(3)
+	})
+
+	it('does not retry a genuine query error just because admission closed in flight', async () => {
+		const admission = new RepositoryClientAdmission()
+		admission.setState({ mode: 'open', flushOperationId: null })
+		let attempts = 0
+		const next = (() =>
+			observable<Envelope>((observer) => {
+				attempts += 1
+				admission.setState({ mode: 'locked', flushOperationId: null })
+				observer.error(new Error('Invalid query input.'))
+			})) as any
+
+		await expect(
+			execute(admission, operation('query', 'agents.catalog'), next)
+		).rejects.toMatchObject({ message: 'Invalid query input.' })
+		admission.setState({ mode: 'open', flushOperationId: null })
+		await Promise.resolve()
+		expect(attempts).toBe(1)
+	})
+
+	it.each(['Failed to fetch', 'Load failed', 'NetworkError when attempting to fetch resource.'])(
+		'defers an in-flight query after the backend restart transport error: %s',
+		async (message) => {
+			const admission = new RepositoryClientAdmission()
+			admission.setState({ mode: 'open', flushOperationId: null })
+			let attempts = 0
+			const next = (() =>
+				observable<Envelope>((observer) => {
+					attempts += 1
+					if (attempts === 1) {
+						admission.setState({ mode: 'locked', flushOperationId: null })
+						observer.error(new Error('tRPC transport failed', { cause: new TypeError(message) }))
+						return
+					}
+					observer.next({ result: { type: 'data', data: 'recovered' } })
+					observer.complete()
+				})) as any
+
+			const pending = execute(admission, operation('query', 'agents.catalog'), next)
+			await Promise.resolve()
+			expect(attempts).toBe(1)
+
+			admission.setState({ mode: 'open', flushOperationId: null })
+			await expect(pending).resolves.toMatchObject({ result: { data: 'recovered' } })
+			expect(attempts).toBe(2)
+		}
+	)
+
+	it('does not retry a fetch transport error while repository admission remains open', async () => {
+		const admission = new RepositoryClientAdmission()
+		admission.setState({ mode: 'open', flushOperationId: null })
+		let attempts = 0
+		const next = (() =>
+			observable<Envelope>((observer) => {
+				attempts += 1
+				observer.error(new TypeError('Failed to fetch'))
+			})) as any
+
+		await expect(
+			execute(admission, operation('query', 'agents.catalog'), next)
+		).rejects.toMatchObject({ message: 'Failed to fetch' })
+		expect(attempts).toBe(1)
+	})
+
+	it('does not notify an observer after a deferred query is unsubscribed', async () => {
+		const admission = new RepositoryClientAdmission()
+		admission.setState({ mode: 'locked', flushOperationId: null })
+		const calls: string[] = []
+		const error = vi.fn()
+		const link = repositoryAdmissionLink<any>(admission)({})
+		const result = link({
+			op: operation('query', 'agents.catalog'),
+			next: successfulNext(calls)
+		} as never)
+
+		const subscription = result.subscribe({ error })
+		subscription.unsubscribe()
+		await Promise.resolve()
+		admission.setState({ mode: 'open', flushOperationId: null })
+		await Promise.resolve()
+
+		expect(error).not.toHaveBeenCalled()
+		expect(calls).toEqual([])
+	})
+
+	it('rejects an already-aborted request instead of leaving it deferred', async () => {
+		const admission = new RepositoryClientAdmission()
+		admission.setState({ mode: 'locked', flushOperationId: null })
+		const calls: string[] = []
+		const controller = new AbortController()
+		controller.abort(new Error('Request was already aborted.'))
+
+		await expect(
+			execute(
+				admission,
+				operation('query', 'agents.catalog', {}, controller.signal),
+				successfulNext(calls)
+			)
+		).rejects.toMatchObject({ message: 'Request was already aborted.' })
+		expect(calls).toEqual([])
+	})
+
+	it('recognizes a wrapped blocked-mutation error', () => {
+		const wrapped = new Error('wrapped', {
+			cause: new GitModeMutationBlockedError('tests.addTest')
+		})
+		expect(isGitModeMutationBlockedError(wrapped)).toBe(true)
+	})
+})