@recombine-ai/bosun 0.16.1 → 0.17.1

package/src/lib/monaco/bosun-theme.ts

@@ -1,88 +1,5 @@
 import type * as Monaco from 'monaco-editor'
 
-export interface PromptDecorations {
-	update: () => void
-	dispose: () => void
-}
-
-export function createPromptDecorations(
-	monaco: typeof Monaco,
-	editor: Monaco.editor.IStandaloneCodeEditor
-) {
-	const collection = editor.createDecorationsCollection()
-
-	function update() {
-		const model = editor.getModel()
-		if (!model) return
-
-		const decorations: Monaco.editor.IModelDeltaDecoration[] = []
-		const lineCount = model.getLineCount()
-
-		for (let lineNumber = 1; lineNumber <= lineCount; lineNumber++) {
-			const lineText = model.getLineContent(lineNumber)
-
-			//  Headings
-			const match = /^(#+)\s/.exec(lineText)
-			if (match) {
-				const level = match[1].length
-				let cls = 'prompt-heading-3'
-
-				if (level === 1) {
-					cls = 'prompt-heading-1'
-				} else if (level === 2) {
-					cls = 'prompt-heading-2'
-				}
-
-				decorations.push({
-					range: new monaco.Range(lineNumber, 1, lineNumber, lineText.length + 1),
-					options: {
-						isWholeLine: true,
-						inlineClassName: cls
-					}
-				})
-			}
-
-			// Symbols '#' and '*'
-			for (let column = 1; column <= lineText.length; column++) {
-				const ch = lineText[column - 1]
-				if (ch === '#' || ch === '*') {
-					decorations.push({
-						range: new monaco.Range(lineNumber, column, lineNumber, column + 1),
-						options: {
-							inlineClassName: 'prompt-symbol'
-						}
-					})
-				}
-			}
-
-			// Subnumbers
-			const subMatch = lineText.match(/^(\s+)(\d+(?:\.\d+)+\.?)(?=[\s)]|$)/)
-			if (subMatch) {
-				const leading = subMatch[1]
-				const numberText = subMatch[2]
-
-				const startColumn = leading.length + 1
-				const endColumn = startColumn + numberText.length
-
-				decorations.push({
-					range: new monaco.Range(lineNumber, startColumn, lineNumber, endColumn),
-					options: {
-						inlineClassName: 'prompt-subnumber'
-					}
-				})
-			}
-		}
-
-		collection.set(decorations)
-	}
-
-	function dispose() {
-		collection.clear()
-	}
-
-	return { update, dispose }
-}
-
 export const bosunDarkTheme: Monaco.editor.IStandaloneThemeData = {
 	base: 'vs-dark',
 	inherit: true,
@@ -110,6 +27,12 @@ export const bosunDarkTheme: Monaco.editor.IStandaloneThemeData = {
 		'editor.inactiveSelectionBackground': '#4B5563A0',
 		'editor.lineHighlightBackground': '#FFFFFF08',
 		'editorLineNumber.background': '#1D1D1D',
+		'diffEditor.insertedTextBackground': '#00B58A33',
+		'diffEditor.insertedLineBackground': '#00B58A1A',
+		'diffEditor.removedTextBackground': '#FF666633',
+		'diffEditor.removedLineBackground': '#FF66661A',
+		'diffEditor.border': '#373737',
+		'diffEditor.diagonalFill': '#76767633',
 
 		// Nunjucks tag highlight (DocumentHighlightProvider)
 		'editor.wordHighlightBackground': '#ff480159'

package/src/lib/monaco/editor-appearance.spec.ts

@@ -0,0 +1,84 @@
+import type * as Monaco from 'monaco-editor'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import {
+	EDITOR_FONT_FAMILY,
+	EDITOR_FONT_SIZE,
+	createPromptWrapController,
+	getEditorAppearanceOptions
+} from './editor-appearance'
+
+describe('getEditorAppearanceOptions', () => {
+	it('keeps prompt appearance in one preset', () => {
+		expect(getEditorAppearanceOptions('prompt', { bottomPadding: 56 })).toMatchObject({
+			theme: 'bosun-dark',
+			fontSize: EDITOR_FONT_SIZE,
+			fontFamily: EDITOR_FONT_FAMILY,
+			wordWrap: 'bounded',
+			wordWrapColumn: 120,
+			wrappingStrategy: 'advanced',
+			bracketPairColorization: { enabled: true },
+			padding: { top: 32, bottom: 56 }
+		})
+	})
+
+	it('keeps test-history appearance in one preset', () => {
+		expect(getEditorAppearanceOptions('test-history')).toMatchObject({
+			fontSize: EDITOR_FONT_SIZE,
+			fontFamily: EDITOR_FONT_FAMILY,
+			wordWrap: 'bounded',
+			wordWrapColumn: 75,
+			wrappingStrategy: 'advanced',
+			scrollbar: { vertical: 'hidden', horizontal: 'hidden' },
+			padding: { top: 4, bottom: 4 }
+		})
+		expect(getEditorAppearanceOptions('test-history', { bottomPadding: 56 }).padding).toEqual({
+			top: 4,
+			bottom: 56
+		})
+	})
+
+	it('preserves Monaco font defaults for generic diffs', () => {
+		const options = getEditorAppearanceOptions('generic')
+		expect(options).not.toHaveProperty('fontSize')
+		expect(options).not.toHaveProperty('fontFamily')
+	})
+})
+
+describe('createPromptWrapController', () => {
+	afterEach(() => vi.unstubAllGlobals())
+
+	it('updates and disposes responsive wrapping', () => {
+		let frame!: FrameRequestCallback
+		let layoutListener!: () => void
+		const cancelAnimationFrame = vi.fn()
+		vi.stubGlobal('requestAnimationFrame', (callback: FrameRequestCallback) => {
+			frame = callback
+			return 7
+		})
+		vi.stubGlobal('cancelAnimationFrame', cancelAnimationFrame)
+
+		const updateOptions = vi.fn()
+		const disposeLayoutListener = vi.fn()
+		const editor = {
+			getLayoutInfo: () => ({ contentWidth: 724 }),
+			getOption: () => ({ typicalHalfwidthCharacterWidth: 7 }),
+			updateOptions,
+			onDidLayoutChange: (listener: () => void) => {
+				layoutListener = listener
+				return { dispose: disposeLayoutListener }
+			}
+		} as unknown as Monaco.editor.IStandaloneCodeEditor
+		const monaco = {
+			editor: { EditorOption: { fontInfo: 0 } }
+		} as unknown as typeof Monaco
+
+		const controller = createPromptWrapController(editor, monaco)
+		expect(frame).toBeTypeOf('function')
+		frame(0)
+		expect(updateOptions).toHaveBeenCalledWith({ wordWrap: 'bounded', wordWrapColumn: 100 })
+		layoutListener()
+		controller.dispose()
+		expect(disposeLayoutListener).toHaveBeenCalledOnce()
+		expect(cancelAnimationFrame).toHaveBeenCalledWith(7)
+	})
+})

package/src/lib/monaco/editor-appearance.ts

@@ -0,0 +1,154 @@
+import type * as Monaco from 'monaco-editor'
+
+export type EditorAppearance = 'generic' | 'prompt' | 'test-history'
+
+export const EDITOR_FONT_SIZE = 14
+export const EDITOR_FONT_FAMILY =
+	'ui-sans-serif, system-ui, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji"'
+
+interface EditorAppearanceOptions {
+	bottomPadding?: number
+}
+
+export function getEditorAppearanceOptions(
+	appearance: EditorAppearance,
+	options: EditorAppearanceOptions = {}
+): Monaco.editor.IStandaloneEditorConstructionOptions {
+	const common: Monaco.editor.IStandaloneEditorConstructionOptions = {
+		theme: 'bosun-dark',
+		lineNumbers: 'off',
+		automaticLayout: true,
+		minimap: { enabled: false }
+	}
+
+	if (appearance === 'prompt') {
+		return {
+			...common,
+			fontSize: EDITOR_FONT_SIZE,
+			fontFamily: EDITOR_FONT_FAMILY,
+			wordBasedSuggestions: 'off',
+			wordWrap: 'bounded',
+			wordWrapColumn: 120,
+			wrappingStrategy: 'advanced',
+			matchBrackets: 'never',
+			bracketPairColorization: { enabled: true },
+			guides: {
+				highlightActiveBracketPair: false,
+				bracketPairs: false,
+				bracketPairsHorizontal: false
+			},
+			selectionHighlight: false,
+			unicodeHighlight: {
+				ambiguousCharacters: false,
+				nonBasicASCII: false,
+				invisibleCharacters: false,
+				includeStrings: false,
+				includeComments: false
+			},
+			autoClosingQuotes: 'never',
+			padding: { top: 32, bottom: options.bottomPadding ?? 0 }
+		}
+	}
+
+	if (appearance === 'test-history') {
+		return {
+			...common,
+			fontSize: EDITOR_FONT_SIZE,
+			fontFamily: EDITOR_FONT_FAMILY,
+			wordBasedSuggestions: 'off',
+			wordWrap: 'bounded',
+			wordWrapColumn: 75,
+			wrappingStrategy: 'advanced',
+			scrollbar: { vertical: 'hidden', horizontal: 'hidden' },
+			overviewRulerLanes: 0,
+			renderLineHighlight: 'none',
+			folding: false,
+			renderWhitespace: 'none',
+			padding: { top: 4, bottom: options.bottomPadding ?? 4 },
+			matchBrackets: 'never',
+			bracketPairColorization: { enabled: false },
+			guides: {
+				highlightActiveBracketPair: false,
+				bracketPairs: false,
+				bracketPairsHorizontal: false
+			},
+			occurrencesHighlight: 'off',
+			selectionHighlight: false,
+			unicodeHighlight: {
+				ambiguousCharacters: false,
+				nonBasicASCII: false,
+				invisibleCharacters: false,
+				includeStrings: false,
+				includeComments: false
+			},
+			autoClosingQuotes: 'never'
+		}
+	}
+
+	return {
+		...common,
+		scrollBeyondLastLine: false,
+		wordWrap: 'on',
+		padding: { bottom: options.bottomPadding ?? 0 },
+		overviewRulerBorder: false,
+		hideCursorInOverviewRuler: true,
+		matchBrackets: 'never',
+		bracketPairColorization: { enabled: false },
+		guides: {
+			highlightActiveBracketPair: false,
+			bracketPairs: false,
+			bracketPairsHorizontal: false
+		},
+		occurrencesHighlight: 'off',
+		selectionHighlight: false,
+		renderLineHighlight: 'none'
+	}
+}
+
+export function createPromptWrapController(
+	editor: Monaco.editor.IStandaloneCodeEditor,
+	monaco: typeof Monaco
+): Monaco.IDisposable {
+	let updateFrame: number | null = null
+	let lastWrapColumn = 0
+	let disposed = false
+
+	function scheduleUpdate() {
+		if (disposed || updateFrame !== null) return
+		updateFrame = requestAnimationFrame(() => {
+			updateFrame = null
+			if (disposed) return
+
+			const layout = editor.getLayoutInfo()
+			const contentWidth = Number(layout?.contentWidth ?? 0)
+			const fontInfo = editor.getOption(monaco.editor.EditorOption.fontInfo) as any
+			const charWidth =
+				Number(fontInfo?.typicalHalfwidthCharacterWidth) ||
+				Number(fontInfo?.typicalFullwidthCharacterWidth) ||
+				7
+			const wrapColumn =
+				Number.isFinite(contentWidth) &&
+				contentWidth > 0 &&
+				Number.isFinite(charWidth) &&
+				charWidth > 0
+					? Math.max(20, Math.floor((contentWidth - 24) / charWidth))
+					: 80
+
+			if (wrapColumn === lastWrapColumn) return
+			lastWrapColumn = wrapColumn
+			editor.updateOptions({ wordWrap: 'bounded', wordWrapColumn: wrapColumn })
+		})
+	}
+
+	const layoutDisposable = editor.onDidLayoutChange(scheduleUpdate)
+	scheduleUpdate()
+
+	return {
+		dispose() {
+			disposed = true
+			layoutDisposable.dispose()
+			if (updateFrame !== null) cancelAnimationFrame(updateFrame)
+			updateFrame = null
+		}
+	}
+}

package/src/lib/monaco/editor-decorations.spec.ts

@@ -0,0 +1,91 @@
+import type * as Monaco from 'monaco-editor'
+import { describe, expect, it, vi } from 'vitest'
+import { createPromptDecorations, createTestEditorDecorations } from './editor-decorations'
+
+class FakeRange {
+	constructor(
+		readonly startLineNumber: number,
+		readonly startColumn: number,
+		readonly endLineNumber: number,
+		readonly endColumn: number
+	) {}
+}
+
+function createFixture(initialLines: string[]) {
+	let lines = initialLines
+	let hasModel = true
+	const set = vi.fn()
+	const clear = vi.fn()
+	const model = {
+		getLineCount: () => lines.length,
+		getLineContent: (lineNumber: number) => lines[lineNumber - 1],
+		getLineMaxColumn: (lineNumber: number) => lines[lineNumber - 1].length + 1
+	}
+	const editor = {
+		createDecorationsCollection: () => ({ set, clear }),
+		getModel: () => (hasModel ? model : null)
+	} as unknown as Monaco.editor.IStandaloneCodeEditor
+	const monaco = { Range: FakeRange } as unknown as typeof Monaco
+
+	return {
+		monaco,
+		editor,
+		set,
+		clear,
+		setLines: (nextLines: string[]) => (lines = nextLines),
+		removeModel: () => (hasModel = false)
+	}
+}
+
+describe('createPromptDecorations', () => {
+	it('styles headings, symbols, and subnumbers from either prompt editor', () => {
+		const fixture = createFixture(['# Title', '  1.2) Detail', '**Important**'])
+		const decorations = createPromptDecorations(fixture.monaco, fixture.editor)
+
+		decorations.update()
+		const applied = fixture.set.mock.calls[0][0] as Monaco.editor.IModelDeltaDecoration[]
+		expect(applied.map((decoration) => decoration.options.inlineClassName)).toEqual(
+			expect.arrayContaining(['prompt-heading-1', 'prompt-symbol', 'prompt-subnumber'])
+		)
+
+		fixture.setLines(['## Changed'])
+		decorations.update()
+		const updated = fixture.set.mock.calls[1][0] as Monaco.editor.IModelDeltaDecoration[]
+		expect(updated.map((decoration) => decoration.options.inlineClassName)).toContain(
+			'prompt-heading-2'
+		)
+
+		decorations.dispose()
+		expect(fixture.clear).toHaveBeenCalledOnce()
+	})
+})
+
+describe('createTestEditorDecorations', () => {
+	it('styles expected output and nested tags from either history editor', () => {
+		const fixture = createFixture(['User: hello', 'Agent: <answer>yes</answer>'])
+		const decorations = createTestEditorDecorations(fixture.monaco, fixture.editor)
+
+		decorations.update([{ startLine: 2, endLine: 2, className: 'test-expected-output' }])
+		const applied = fixture.set.mock.calls[0][0] as Monaco.editor.IModelDeltaDecoration[]
+		expect(applied.map((decoration) => decoration.options.inlineClassName)).toEqual([
+			'test-expected-output',
+			'test-expected-output-tag',
+			'test-expected-output-tag'
+		])
+	})
+
+	it('replaces stale ranges and clears when the model is removed', () => {
+		const fixture = createFixture(['Agent: old'])
+		const decorations = createTestEditorDecorations(fixture.monaco, fixture.editor)
+
+		decorations.update([{ startLine: 1, endLine: 1, className: 'test-expected-output' }])
+		fixture.setLines(['User: new', 'Agent: new'])
+		decorations.update([{ startLine: 2, endLine: 2, className: 'test-expected-output' }])
+		const updated = fixture.set.mock.calls[1][0] as Monaco.editor.IModelDeltaDecoration[]
+		expect((updated[0].range as FakeRange).startLineNumber).toBe(2)
+
+		fixture.removeModel()
+		decorations.update([])
+		expect(fixture.clear).toHaveBeenCalledOnce()
+	})
+})

package/src/lib/monaco/editor-decorations.ts

@@ -0,0 +1,133 @@
+import type * as Monaco from 'monaco-editor'
+
+export interface EditorHighlight {
+	startLine: number
+	endLine: number
+	className: string
+}
+
+export interface PromptDecorations {
+	update: () => void
+	dispose: () => void
+}
+
+export interface TestEditorDecorations {
+	update: (highlights: readonly EditorHighlight[]) => void
+	dispose: () => void
+}
+
+export function createPromptDecorations(
+	monaco: typeof Monaco,
+	editor: Monaco.editor.IStandaloneCodeEditor
+): PromptDecorations {
+	const collection = editor.createDecorationsCollection()
+
+	function update() {
+		const model = editor.getModel()
+		if (!model) {
+			collection.clear()
+			return
+		}
+
+		const decorations: Monaco.editor.IModelDeltaDecoration[] = []
+		const lineCount = model.getLineCount()
+
+		for (let lineNumber = 1; lineNumber <= lineCount; lineNumber++) {
+			const lineText = model.getLineContent(lineNumber)
+			const heading = /^(#+)\s/.exec(lineText)
+			if (heading) {
+				const level = heading[1].length
+				const className =
+					level === 1 ? 'prompt-heading-1' : level === 2 ? 'prompt-heading-2' : 'prompt-heading-3'
+				decorations.push({
+					range: new monaco.Range(lineNumber, 1, lineNumber, lineText.length + 1),
+					options: { isWholeLine: true, inlineClassName: className }
+				})
+			}
+
+			for (let column = 1; column <= lineText.length; column++) {
+				const character = lineText[column - 1]
+				if (character !== '#' && character !== '*') continue
+				decorations.push({
+					range: new monaco.Range(lineNumber, column, lineNumber, column + 1),
+					options: { inlineClassName: 'prompt-symbol' }
+				})
+			}
+
+			const subnumber = lineText.match(/^(\s+)(\d+(?:\.\d+)+\.?)(?=[\s)]|$)/)
+			if (!subnumber) continue
+			const startColumn = subnumber[1].length + 1
+			decorations.push({
+				range: new monaco.Range(
+					lineNumber,
+					startColumn,
+					lineNumber,
+					startColumn + subnumber[2].length
+				),
+				options: { inlineClassName: 'prompt-subnumber' }
+			})
+		}
+
+		collection.set(decorations)
+	}
+
+	return {
+		update,
+		dispose: () => collection.clear()
+	}
+}
+
+export function createTestEditorDecorations(
+	monaco: typeof Monaco,
+	editor: Monaco.editor.IStandaloneCodeEditor
+): TestEditorDecorations {
+	const collection = editor.createDecorationsCollection()
+
+	function update(highlights: readonly EditorHighlight[]) {
+		const model = editor.getModel()
+		if (!model) {
+			collection.clear()
+			return
+		}
+
+		const decorations: Monaco.editor.IModelDeltaDecoration[] = []
+		const lineCount = model.getLineCount()
+		for (const highlight of highlights) {
+			const startLine = Math.max(1, Math.min(lineCount, Number(highlight.startLine) || 1))
+			const endLine = Math.max(
+				startLine,
+				Math.min(lineCount, Number(highlight.endLine) || startLine)
+			)
+			decorations.push({
+				range: new monaco.Range(startLine, 1, endLine, model.getLineMaxColumn(endLine)),
+				options: { inlineClassName: highlight.className }
+			})
+
+			if (highlight.className !== 'test-expected-output') continue
+			for (let lineNumber = startLine; lineNumber <= endLine; lineNumber++) {
+				const lineText = model.getLineContent(lineNumber)
+				const tagPattern = /<\/?[A-Za-z][^>]*?>/g
+				let match: RegExpExecArray | null
+				while ((match = tagPattern.exec(lineText))) {
+					const startColumn = match.index + 1
+					const endColumn = Math.min(
+						model.getLineMaxColumn(lineNumber),
+						startColumn + match[0].length
+					)
+					if (endColumn <= startColumn) continue
+					decorations.push({
+						range: new monaco.Range(lineNumber, startColumn, lineNumber, endColumn),
+						options: { inlineClassName: 'test-expected-output-tag' }
+					})
+				}
+			}
+		}
+
+		collection.set(decorations)
+	}
+
+	return {
+		update,
+		dispose: () => collection.clear()
+	}
+}

package/src/lib/tests/assertion-types.ts

@@ -0,0 +1,74 @@
+export type AssertionOption = { value: string; label: string }
+
+const baseAssertionTypes: AssertionOption[] = [
+	{ value: 'llm-rubric', label: 'LLM' },
+	{ value: 'answer-relevance', label: 'Answer Relevance (LLM)' },
+	{ value: 'context-faithfulness', label: 'Context Faithfulness (LLM)' },
+	{ value: 'context-recall', label: 'Context Recall (LLM)' },
+	{ value: 'context-relevance', label: 'Context Relevance (LLM)' },
+	{ value: 'model-graded-closedqa', label: 'Model-Graded Closed QA' },
+	{ value: 'model-graded-factuality', label: 'Model-Graded Factuality' },
+	{ value: 'moderation', label: 'Moderation' },
+	{ value: 'classifier', label: 'Classifier' },
+	{ value: 'g-eval', label: 'G-Eval' },
+	{ value: 'factuality', label: 'Factuality' },
+	{ value: 'conversation-relevance', label: 'Conversation Relevance' },
+
+	{ value: 'equals', label: 'Equals' },
+	{ value: 'contains', label: 'Contains' },
+	{ value: 'icontains', label: 'Contains (case-insensitive)' },
+	{ value: 'contains-all', label: 'Contains All' },
+	{ value: 'contains-any', label: 'Contains Any' },
+	{ value: 'icontains-all', label: 'Contains All (iCase)' },
+	{ value: 'icontains-any', label: 'Contains Any (iCase)' },
+	{ value: 'starts-with', label: 'Starts With' },
+	{ value: 'regex', label: 'Regex' },
+	{ value: 'levenshtein', label: 'Levenshtein Distance' },
+	{ value: 'is-refusal', label: 'Is Refusal' },
+
+	{ value: 'is-html', label: 'Is HTML' },
+	{ value: 'contains-html', label: 'Contains HTML' },
+	{ value: 'is-json', label: 'Is JSON' },
+	{ value: 'contains-json', label: 'Contains JSON' },
+	{ value: 'is-xml', label: 'Is XML' },
+	{ value: 'contains-xml', label: 'Contains XML' },
+	{ value: 'is-sql', label: 'Is SQL' },
+	{ value: 'contains-sql', label: 'Contains SQL' },
+
+	{ value: 'similar', label: 'Semantic Similarity' },
+	{ value: 'rouge-n', label: 'ROUGE-N' },
+	{ value: 'bleu', label: 'BLEU' },
+	{ value: 'gleu', label: 'GLEU' },
+	{ value: 'meteor', label: 'METEOR' },
+	{ value: 'perplexity', label: 'Perplexity' },
+	{ value: 'perplexity-score', label: 'Perplexity Score' },
+
+	{ value: 'latency', label: 'Latency' },
+	{ value: 'cost', label: 'Cost' },
+	{ value: 'finish-reason', label: 'Finish Reason' },
+	{ value: 'trace-error-spans', label: 'Trace Error Spans' },
+	{ value: 'trace-span-count', label: 'Trace Span Count' },
+	{ value: 'trace-span-duration', label: 'Trace Span Duration' },
+
+	{ value: 'is-valid-function-call', label: 'Is Valid Function Call' },
+	{ value: 'is-valid-openai-function-call', label: 'Is Valid OpenAI Function Call' },
+	{ value: 'is-valid-openai-tools-call', label: 'Is Valid OpenAI Tools Call' },
+	{ value: 'guardrails', label: 'Guardrails' },
+
+	{ value: 'javascript', label: 'JavaScript (custom)' },
+	{ value: 'python', label: 'Python (custom)' },
+	{ value: 'webhook', label: 'Webhook (custom)' },
+	{ value: 'pi', label: 'Pi Scorer' }
+]
+
+export const assertionTypes: AssertionOption[] = [
+	...baseAssertionTypes,
+	...baseAssertionTypes.map((option) => ({
+		value: `not-${option.value}`,
+		label: `Not ${option.label}`
+	}))
+]
+
+export function assertionLabel(value: string): string {
+	return assertionTypes.find((option) => option.value === value)?.label ?? value
+}

package/src/lib/trpc-client.ts

@@ -1,16 +1,30 @@
 import { env } from '$env/dynamic/public'
 import { createTRPCClient, httpLink } from '@trpc/client'
 import type { AppRouter } from '../backend/server'
+import { repositoryAdmissionLink, repositoryClientAdmission } from './git-mode/client-admission'
 
-const trpcUrl =
+export const trpcUrl =
 	env.PUBLIC_TRPC_URL ??
 	`http://${env.PUBLIC_TRPC_HOSTNAME ?? 'localhost'}:${env.PUBLIC_TRPC_PORT ?? '2022'}`
 
 // ref: https://github.com/trpc/trpc/blob/main/examples/standalone-server/src/client.ts
 export const trpc = createTRPCClient<AppRouter>({
 	links: [
+		repositoryAdmissionLink<AppRouter>(repositoryClientAdmission),
 		httpLink({
 			url: trpcUrl
 		})
 	]
 })
+
+export function unregisterGitModeTab(tabId: string): Promise<void> {
+	if (!tabId || typeof window === 'undefined') return Promise.resolve()
+	return fetch(`${trpcUrl}/gitMode.unregister`, {
+		method: 'POST',
+		headers: { 'content-type': 'application/json' },
+		body: JSON.stringify({ tabId }),
+		keepalive: true
+	})
+		.then(() => undefined)
+		.catch(() => undefined)
+}