@recombine-ai/bosun 0.16.0 → 0.16.2-cloud-1

package/src/backend/tests/suite.ts

@@ -1,231 +0,0 @@
-import { access, mkdir, readFile, readdir, rename, unlink, writeFile } from 'node:fs/promises'
-import path from 'node:path'
-import { dump, load } from 'js-yaml'
-import { z } from 'zod'
-
-import { getRootPath } from '../lib/get-root-path'
-import { getProjectBasePath } from '../lib/project-api'
-
-export const LEGACY_TEST_SUITE_ERROR_PREFIX = 'BOSUN_LEGACY_TEST_SUITE:'
-
-export const TestRowSchema = z.object({
-	id: z.string(),
-	order: z.number(),
-	pinned: z.enum(['TRUE', 'FALSE']),
-	scenario: z.string(),
-	step: z.string().optional(),
-	author: z.string().optional(),
-	category: z.string().optional(),
-	assertion_type: z.string(),
-	assertion_value: z.string(),
-	conversation: z.string(),
-	expected_output: z.string(),
-	evaluation_mode: z.enum(['assertion', 'json-deep-equal']).optional(),
-	context_mode: z.enum(['merge', 'replace']).optional(),
-	timeout: z.string(),
-	similarity_threshold: z.string(),
-	context: z.record(z.unknown()),
-	mocks: z.record(z.unknown()).optional()
-})
-
-const StoredTestSchema = TestRowSchema.omit({ id: true })
-
-export const TestSuiteSchema = z.object({
-	tests: z.array(TestRowSchema)
-})
-
-export type TestRow = z.infer<typeof TestRowSchema>
-export type TestSuite = z.infer<typeof TestSuiteSchema>
-
-const suiteMutationQueue = new Map<string, Promise<void>>()
-
-async function exists(targetPath: string): Promise<boolean> {
-	try {
-		await access(targetPath)
-		return true
-	} catch {
-		return false
-	}
-}
-
-async function getLegacySuiteFiles(suiteKey: string): Promise<string[]> {
-	const legacyDirectory = path.dirname(await getRootPath())
-	const candidates = [
-		path.join(legacyDirectory, `${suiteKey}.tests.jsonl`),
-		path.join(legacyDirectory, `${suiteKey}.tests.json`),
-		path.join(legacyDirectory, `${suiteKey}.config.json`)
-	]
-	const matches = await Promise.all(
-		candidates.map(async (candidate) => ((await exists(candidate)) ? candidate : null))
-	)
-	return matches.filter((candidate): candidate is string => candidate !== null)
-}
-
-function legacySuiteError(suiteKey: string, files: string[]): Error {
-	return new Error(
-		`${LEGACY_TEST_SUITE_ERROR_PREFIX} Test suite '${suiteKey}' uses the unsupported JSON/JSONL format. ` +
-			`Migrate it to per-test YAML files before using this version of Bosun. Legacy files: ${files.join(', ')}`
-	)
-}
-
-export async function getSuiteDirectory(suiteKey: string): Promise<string> {
-	if (!suiteKey || path.basename(suiteKey) !== suiteKey || suiteKey === '.' || suiteKey === '..') {
-		throw new Error(`Invalid test suite key: '${suiteKey}'`)
-	}
-
-	const legacyFiles = await getLegacySuiteFiles(suiteKey)
-	if (legacyFiles.length > 0) throw legacySuiteError(suiteKey, legacyFiles)
-
-	const agentsPath = await getProjectBasePath()
-	const entries = await readdir(agentsPath, { withFileTypes: true })
-	const matches: string[] = []
-
-	for (const entry of entries) {
-		if (!entry.isDirectory()) continue
-		const candidate = path.join(agentsPath, entry.name, 'bosun-tests', suiteKey)
-		if (await exists(candidate)) matches.push(candidate)
-	}
-
-	if (matches.length === 0) {
-		throw new Error(
-			`Test suite '${suiteKey}' was not found under ${agentsPath}/*/bosun-tests/${suiteKey}`
-		)
-	}
-	if (matches.length > 1) {
-		throw new Error(
-			`Test suite '${suiteKey}' exists in multiple agent directories: ${matches.join(', ')}`
-		)
-	}
-	return matches[0]
-}
-
-export async function withSuiteMutationLock<T>(suiteKey: string, fn: () => Promise<T>): Promise<T> {
-	const previous = suiteMutationQueue.get(suiteKey) ?? Promise.resolve()
-	let release!: () => void
-	const gate = new Promise<void>((resolve) => {
-		release = resolve
-	})
-	const queued = previous.catch(() => {}).then(() => gate)
-	suiteMutationQueue.set(suiteKey, queued)
-
-	await previous.catch(() => {})
-
-	try {
-		return await fn()
-	} finally {
-		release()
-		if (suiteMutationQueue.get(suiteKey) === queued) {
-			suiteMutationQueue.delete(suiteKey)
-		}
-	}
-}
-
-function testFileName(id: string): string {
-	if (!id || path.basename(id) !== id || id === '.' || id === '..') {
-		throw new Error(`Invalid test id for a file name: '${id}'`)
-	}
-	return `${id}.yaml`
-}
-
-export async function readSuite(suiteKey: string): Promise<TestSuite> {
-	const suiteDirectory = await getSuiteDirectory(suiteKey)
-	const files = (await readdir(suiteDirectory, { withFileTypes: true }))
-		.filter(
-			(entry) => entry.isFile() && entry.name.endsWith('.yaml') && !entry.name.startsWith('.')
-		)
-		.map((entry) => entry.name)
-	const rows = await Promise.all(
-		files.map(async (fileName) => {
-			const id = fileName.slice(0, -'.yaml'.length)
-			try {
-				const parsed = load(await readFile(path.join(suiteDirectory, fileName), 'utf8'))
-				return normalizeRow({ id, ...StoredTestSchema.parse(parsed) })
-			} catch (error) {
-				throw new Error(`Error loading test '${id}' from ${path.join(suiteDirectory, fileName)}`, {
-					cause: error
-				})
-			}
-		})
-	)
-
-	rows.sort((a, b) => a.order - b.order || a.id.localeCompare(b.id))
-	return { tests: rows }
-}
-
-function serializeRow(row: TestRow): string {
-	const normalized = normalizeRow(row)
-	const { id: _id, ...stored } = normalized
-	return dump(StoredTestSchema.parse(stored), {
-		lineWidth: -1,
-		noRefs: true,
-		noCompatMode: true
-	})
-}
-
-async function writeRow(suiteDirectory: string, row: TestRow): Promise<void> {
-	const destination = path.join(suiteDirectory, testFileName(row.id))
-	const body = serializeRow(row)
-	try {
-		if ((await readFile(destination, 'utf8')) === body) return
-	} catch {
-		// New test.
-	}
-
-	const temporary = path.join(
-		suiteDirectory,
-		`.${path.basename(destination)}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`
-	)
-	await writeFile(temporary, body, 'utf8')
-	try {
-		await rename(temporary, destination)
-	} catch {
-		try {
-			await unlink(destination)
-		} catch {
-			// Destination did not exist.
-		}
-		await rename(temporary, destination)
-	}
-}
-
-export async function writeSuite(suiteKey: string, suite: TestSuite): Promise<void> {
-	const suiteDirectory = await getSuiteDirectory(suiteKey)
-	await mkdir(suiteDirectory, { recursive: true })
-	const expectedFiles = new Set(suite.tests.map((row) => testFileName(row.id)))
-	const existingFiles = (await readdir(suiteDirectory, { withFileTypes: true }))
-		.filter(
-			(entry) => entry.isFile() && entry.name.endsWith('.yaml') && !entry.name.startsWith('.')
-		)
-		.map((entry) => entry.name)
-
-	await Promise.all(suite.tests.map((row) => writeRow(suiteDirectory, row)))
-	await Promise.all(
-		existingFiles
-			.filter((fileName) => !expectedFiles.has(fileName))
-			.map((fileName) => unlink(path.join(suiteDirectory, fileName)))
-	)
-}
-
-export function normalizeRow(r: any): TestRow {
-	const row: TestRow = {
-		id: String(r.id || ''),
-		order: Number.isFinite(Number(r.order)) ? Number(r.order) : 0,
-		pinned: String(r.pinned || 'TRUE').toUpperCase() === 'TRUE' ? 'TRUE' : 'FALSE',
-		scenario: String(r.scenario || ''),
-		step: String(r.step || 'main'),
-		author: r.author != null ? String(r.author) : '',
-		category: r.category != null ? String(r.category) : '',
-		assertion_type: String(r.assertion_type || 'llm-rubric'),
-		assertion_value: String(r.assertion_value || ''),
-		conversation: String(r.conversation || ''),
-		expected_output: String(r.expected_output || ''),
-		timeout: String(r.timeout ?? '0'),
-		similarity_threshold: String(r.similarity_threshold ?? '50'),
-		context: r.context || {}
-	}
-	if (r.evaluation_mode === 'json-deep-equal') row.evaluation_mode = 'json-deep-equal'
-	else row.evaluation_mode = 'assertion'
-	row.context_mode = r.context_mode === 'replace' ? 'replace' : 'merge'
-	if (typeof r.mocks !== 'undefined') row.mocks = r.mocks || {}
-	return row
-}

package/src/backend/traces/latency-recordings.ts

@@ -1,176 +0,0 @@
-import { createHash } from 'node:crypto'
-import fs from 'node:fs/promises'
-import path from 'node:path'
-import { getProjectDataDir } from '../lib/project-data-dir'
-
-const LATENCY_ROOT_SEGMENTS = ['data', 'latency']
-const RECORDING_FILE_NAME = 'recording.wav'
-const METADATA_FILE_NAME = 'metadata.json'
-
-export type LatencyRecordingMetadata = {
-	conversationId: string
-	sourceId: string
-	fileName: string
-	mimeType: string
-	size: number
-	uploadedAt: string
-	alignmentOffsetMs: number
-}
-
-export type LatencyRecordingRecord = LatencyRecordingMetadata & {
-	audioPath: string
-}
-
-function normalizeSourceId(sourceId: string | null | undefined): string {
-	const trimmed = String(sourceId ?? '').trim()
-	return trimmed || 'default'
-}
-
-function makeSafePathSegment(raw: string, fallback: string): string {
-	const trimmed = String(raw ?? '').trim()
-	const value = trimmed || fallback
-	const slug =
-		value
-			.slice(0, 80)
-			.replace(/[^a-zA-Z0-9._-]+/g, '_')
-			.replace(/^_+|_+$/g, '') || fallback
-	const hash = createHash('sha1').update(value).digest('hex').slice(0, 12)
-	return `${slug}-${hash}`
-}
-
-async function resolveConversationDir(
-	conversationId: string,
-	sourceId: string | null | undefined
-): Promise<string> {
-	const normalizedSourceId = normalizeSourceId(sourceId)
-
-	return getProjectDataDir(
-		...LATENCY_ROOT_SEGMENTS.slice(1),
-		makeSafePathSegment(normalizedSourceId, 'source'),
-		makeSafePathSegment(conversationId, 'conversation')
-	)
-}
-
-async function readMetadataFile(filePath: string): Promise<LatencyRecordingMetadata | null> {
-	try {
-		const raw = await fs.readFile(filePath, 'utf-8')
-		const parsed = JSON.parse(raw) as Partial<LatencyRecordingMetadata>
-		if (
-			typeof parsed?.conversationId !== 'string' ||
-			typeof parsed?.sourceId !== 'string' ||
-			typeof parsed?.fileName !== 'string' ||
-			typeof parsed?.mimeType !== 'string' ||
-			typeof parsed?.size !== 'number' ||
-			typeof parsed?.uploadedAt !== 'string' ||
-			typeof parsed?.alignmentOffsetMs !== 'number'
-		) {
-			return null
-		}
-		return parsed as LatencyRecordingMetadata
-	} catch (error) {
-		if ((error as NodeJS.ErrnoException).code === 'ENOENT') return null
-		console.error('Failed to read latency recording metadata:', filePath, error)
-		return null
-	}
-}
-
-async function writeMetadataFile(filePath: string, metadata: LatencyRecordingMetadata) {
-	await fs.mkdir(path.dirname(filePath), { recursive: true })
-	await fs.writeFile(filePath, JSON.stringify(metadata, null, 2), 'utf-8')
-}
-
-export function isWavBytes(bytes: Uint8Array): boolean {
-	if (!(bytes instanceof Uint8Array) || bytes.byteLength < 12) return false
-
-	const riff = bytes[0] === 0x52 && bytes[1] === 0x49 && bytes[2] === 0x46 && bytes[3] === 0x46
-	const wave = bytes[8] === 0x57 && bytes[9] === 0x41 && bytes[10] === 0x56 && bytes[11] === 0x45
-
-	return riff && wave
-}
-
-export async function getLatencyRecording(
-	conversationId: string,
-	sourceId: string | null | undefined
-): Promise<LatencyRecordingRecord | null> {
-	const normalizedSourceId = normalizeSourceId(sourceId)
-	const dirPath = await resolveConversationDir(conversationId, normalizedSourceId)
-	const audioPath = path.join(dirPath, RECORDING_FILE_NAME)
-	const metadataPath = path.join(dirPath, METADATA_FILE_NAME)
-
-	const [metadata, audioStat] = await Promise.all([
-		readMetadataFile(metadataPath),
-		fs.stat(audioPath).catch((error: NodeJS.ErrnoException) => {
-			if (error.code === 'ENOENT') return null
-			throw error
-		})
-	])
-
-	if (!metadata || !audioStat?.isFile()) return null
-
-	return {
-		...metadata,
-		audioPath,
-		size: Number.isFinite(metadata.size) && metadata.size > 0 ? metadata.size : audioStat.size
-	}
-}
-
-export async function saveLatencyRecording(input: {
-	conversationId: string
-	sourceId: string | null | undefined
-	fileName: string
-	mimeType: string
-	bytes: Uint8Array
-}) {
-	const normalizedSourceId = normalizeSourceId(input.sourceId)
-	const dirPath = await resolveConversationDir(input.conversationId, normalizedSourceId)
-	const audioPath = path.join(dirPath, RECORDING_FILE_NAME)
-	const metadataPath = path.join(dirPath, METADATA_FILE_NAME)
-
-	await fs.mkdir(dirPath, { recursive: true })
-	await fs.writeFile(audioPath, input.bytes)
-
-	const metadata: LatencyRecordingMetadata = {
-		conversationId: input.conversationId,
-		sourceId: normalizedSourceId,
-		fileName: input.fileName.trim() || RECORDING_FILE_NAME,
-		mimeType: input.mimeType.trim() || 'audio/wav',
-		size: input.bytes.byteLength,
-		uploadedAt: new Date().toISOString(),
-		alignmentOffsetMs: 0
-	}
-
-	await writeMetadataFile(metadataPath, metadata)
-
-	return {
-		...metadata,
-		audioPath
-	} satisfies LatencyRecordingRecord
-}
-
-export async function updateLatencyRecordingAlignment(input: {
-	conversationId: string
-	sourceId: string | null | undefined
-	alignmentOffsetMs: number
-}) {
-	const existing = await getLatencyRecording(input.conversationId, input.sourceId)
-	if (!existing) return null
-
-	const dirPath = await resolveConversationDir(input.conversationId, existing.sourceId)
-	const metadataPath = path.join(dirPath, METADATA_FILE_NAME)
-	const metadata: LatencyRecordingMetadata = {
-		conversationId: existing.conversationId,
-		sourceId: existing.sourceId,
-		fileName: existing.fileName,
-		mimeType: existing.mimeType,
-		size: existing.size,
-		uploadedAt: existing.uploadedAt,
-		alignmentOffsetMs: input.alignmentOffsetMs
-	}
-
-	await writeMetadataFile(metadataPath, metadata)
-
-	return {
-		...metadata,
-		audioPath: existing.audioPath
-	} satisfies LatencyRecordingRecord
-}

package/src/lib/agent-catalog.ts

@@ -1,4 +0,0 @@
-export type AgentCatalogEntry = {
-	id: string
-	displayName: string
-}

package/src/lib/agents-context.ts

@@ -1,8 +0,0 @@
-import { createContext } from 'svelte'
-
-export interface AgentsContext {
-	onAgentSelect: (agentName: string) => void
-	onError: (errorMessage: string) => void
-}
-
-export const [getAgentsContext, setAgentsContext] = createContext<AgentsContext>()

package/src/lib/api-telescope/client.ts

@@ -1,174 +0,0 @@
-import { z } from 'zod'
-import * as types from './types'
-
-export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS'
-
-const SOURCE_HEADER = 'x-bosun-telescope-source'
-
-export class TelescopeClient {
-	/**
-	 * @param fetchFn Custom fetch function (e.g., from SvelteKit's load context). Defaults to global fetch if not provided.
-	 */
-	constructor(
-		private fetchFn: typeof fetch = globalThis.fetch, // Default to global fetch if not provided
-		private sourceId?: string
-	) {}
-
-	public setSourceId(sourceId: string | undefined) {
-		this.sourceId = sourceId
-	}
-
-	/**
-	 * Get the actual URL to use (always uses proxy)
-	 */
-	private getUrl(path: string): string {
-		const cleanPath = path.startsWith('/') ? path.slice(1) : path
-		const pathWithoutDev = cleanPath.replace(/^dev\//, '')
-		return `/traces/api/proxy/${pathWithoutDev}`
-	}
-
-	/**
-	 * Fetch data from the telescope API
-	 * @param method HTTP method
-	 * @param path path to fetch
-	 * @param schema Zod schema to parse the response
-	 * @returns parsed JSON response
-	 */
-	private async fetch<T>(method: HttpMethod, path: string, schema: z.ZodType<T>): Promise<T>
-	private async fetch(method: HttpMethod, path: string): Promise<Response>
-	private async fetch<T>(
-		method: HttpMethod = 'GET',
-		path: string,
-		schema?: z.ZodType<T>
-	): Promise<T | Response> {
-		const url = this.getUrl(path)
-		// No auth headers needed - proxy handles authentication
-		const headers: Record<string, string> = {}
-		if (this.sourceId && this.sourceId.trim()) {
-			headers[SOURCE_HEADER] = this.sourceId
-		}
-
-		const response = await this.fetchFn(url, { method, headers })
-
-		if (!response) {
-			throw new Error('No response from server')
-		}
-
-		if (!response.ok) {
-			throw new Error(`Error fetching data: ${response.statusText}`)
-		}
-
-		if (schema) {
-			return schema.parse(await response.json())
-		}
-
-		return response
-	}
-
-	/**
-	 * Get a list of conversations
-	 * @param phoneNumber full or partial phone number
-	 * @param limit number of conversations to fetch
-	 * @param lastConversationId id of the last conversation from the previous page, for pagination
-	 * @returns a list of conversations
-	 */
-	public async getConversations(
-		params: types.GetConversationsRequest = {}
-	): Promise<types.PaginatedConversationsResponse> {
-		const searchParams = new URLSearchParams({ limit: params.limit?.toString() ?? '10' })
-		if (params.lastConversationId)
-			searchParams.append('lastConversationId', params.lastConversationId)
-		if (params.phoneNumber) searchParams.append('phoneNumber', params.phoneNumber)
-		if (params.agentId) searchParams.append('agentId', params.agentId)
-
-		const res = await this.fetch('GET', `/conversations?${searchParams.toString()}`)
-		if (!res.ok) {
-			throw new Error(`Error fetching conversations: ${res.status} ${res.statusText}`)
-		}
-
-		const json: any = await res.json()
-
-		if (Array.isArray(json?.items)) {
-			json.items = json.items.map((it: any) => ({
-				...it,
-				phoneNumber: typeof it?.phoneNumber === 'string' ? it.phoneNumber : ''
-			}))
-		} else {
-			json.items = []
-		}
-
-		return types.PaginatedConversationsResponseSchema.parse(json)
-	}
-
-	/**
-	 * Get a single conversation by ID
-	 * @param conversationId the conversation ID
-	 * @returns a single conversation
-	 */
-	public async getConversation(conversationId: string): Promise<types.Conversation> {
-		return await this.fetch<types.Conversation>(
-			'GET',
-			`/conversations/${conversationId}`,
-			types.ConversationSchema
-		)
-	}
-
-	/**
-	 * Get mixed traces for a conversation (chronological timeline)
-	 * @param conversationId the conversation ID
-	 * @param limit number of traces to fetch
-	 * @param lastTraceId id of the last trace from the previous page, for pagination
-	 * @returns paginated traces
-	 */
-	public async getTraces(
-		conversationId: string,
-		limit?: number,
-		lastTraceId?: string
-	): Promise<types.PaginatedTracesResponse> {
-		const params = new URLSearchParams()
-		if (limit) params.set('limit', String(limit))
-		if (lastTraceId) params.set('lastTraceId', lastTraceId)
-
-		const path = `/conversations/${conversationId}/traces${
-			params.toString() ? `?${params.toString()}` : ''
-		}`
-
-		const res = await this.fetch('GET', path)
-		if (!res.ok) {
-			throw new Error(`Failed to fetch traces: ${res.status} ${res.statusText}`)
-		}
-		return types.PaginatedTracesResponseSchema.parse(await res.json())
-	}
-
-	public async getLatencyTraces(
-		conversationId: string,
-		limit?: number,
-		lastTraceId?: string
-	): Promise<types.PaginatedLatencyTracesResponse> {
-		const params = new URLSearchParams()
-		params.set('traceType', 'LATENCY')
-		if (limit) params.set('limit', String(limit))
-		if (lastTraceId) params.set('lastTraceId', lastTraceId)
-
-		const path = `/conversations/${conversationId}/traces${
-			params.toString() ? `?${params.toString()}` : ''
-		}`
-
-		const res = await this.fetch('GET', path)
-		if (!res.ok) {
-			throw new Error(`Failed to fetch latency traces: ${res.status} ${res.statusText}`)
-		}
-		return types.PaginatedLatencyTracesResponseSchema.parse(await res.json())
-	}
-
-	// Backwards-compatible aliases (older UI paths)
-	public getCalls(params: types.GetConversationsRequest = {}) {
-		return this.getConversations(params)
-	}
-	public getCall(conversationId: string) {
-		return this.getConversation(conversationId)
-	}
-	public getStepTraces(conversationId: string, limit?: number) {
-		return this.getTraces(conversationId, limit)
-	}
-}

package/src/lib/api-telescope/index.ts

@@ -1,4 +0,0 @@
-import * as types from './types'
-import { TelescopeClient } from './client'
-
-export { types, TelescopeClient }

package/src/lib/api-telescope/latency-timeline-view-state.spec.ts

@@ -1,25 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { rebaseLatencyTimelineViewport } from './latency-timeline-view-state'
-
-describe('rebaseLatencyTimelineViewport', () => {
-	it('preserves relative timestamps when the reloaded trace origin changes', () => {
-		const previousOriginMs = 1_700_000_000_000
-		const nextOriginMs = previousOriginMs + 200_000
-
-		expect(
-			rebaseLatencyTimelineViewport(
-				{
-					startMs: previousOriginMs + 5_000,
-					endMs: previousOriginMs + 35_000,
-					originMs: previousOriginMs
-				},
-				nextOriginMs
-			)
-		).toEqual({
-			startMs: nextOriginMs + 5_000,
-			endMs: nextOriginMs + 35_000,
-			originMs: nextOriginMs
-		})
-	})
-})