@recombine-ai/bosun 0.1.0

package/src/ws-server/fs-persistence.ts

@@ -0,0 +1,80 @@
+import { type AgentState } from './agents'
+import fs from 'fs'
+import path from 'path'
+
+export interface StatePersistence {
+	load: (agentId: string) => Promise<AgentState[]>
+	save: (agentId: string, states: AgentState[]) => Promise<void>
+}
+
+export type Context = Record<string, any>
+
+export interface ContextPersistence {
+	load: (agentId: string, contextName: string) => Promise<Context>
+	save: (agentId: string, contextName: string, context: Context) => Promise<void>
+}
+
+export const fsStatePersistence: StatePersistence = {
+	load: async (agentId: string) => {
+		const filePath = path.join('.', 'data', 'history', `${agentId}.json`)
+		return fsPersistence.load(filePath)
+	},
+	save: async (agentId: string, states: AgentState[]) => {
+		const filePath = path.join('.', 'data', 'history', `${agentId}.json`)
+		return fsPersistence.save(filePath, states)
+	}
+}
+
+export const fsContextPersistence: ContextPersistence = {
+	load: async (agentId: string, contextName: string) => {
+		const filePath = path.join('.', 'data', 'contexts', contextName, `${agentId}.json`)
+		return fsPersistence.load(filePath)
+	},
+	save: async (agentId: string, contextName: string, context: Context) => {
+		const filePath = path.join('.', 'data', 'contexts', contextName, `${agentId}.json`)
+		return fsPersistence.save(filePath, context)
+	}
+}
+
+const fsPersistence = {
+	load: async (filePath: string) => {
+		try {
+			const data = String(await fs.promises.readFile(filePath))
+			return data ? JSON.parse(data) : ''
+		} catch (error) {
+			if ((error as any).code === 'ENOENT') {
+				await createFileIfNotExists(filePath)
+				return ''
+			}
+			console.error('error loading: ', filePath, String(await fs.promises.readFile(filePath)))
+			throw error
+		}
+	},
+	// TODO replace with JSONObject | JSONArray
+	save: async (filePath: string, toSave: Object) => {
+		await createFileIfNotExists(filePath)
+		await fs.promises.writeFile(filePath, JSON.stringify(toSave, null, 2))
+	}
+}
+
+/**
+ * Ensures that a file exists by creating any necessary parent directories and the file itself
+ * @param filePath Path to the file, may include nested directories
+ */
+async function createFileIfNotExists(filePath: string) {
+	const directory = path.dirname(filePath)
+
+	try {
+		await fs.promises.access(directory)
+	} catch (error) {
+		// Directory doesn't exist, create it recursively
+		await fs.promises.mkdir(directory, { recursive: true })
+	}
+
+	try {
+		await fs.promises.access(filePath)
+	} catch (error) {
+		// File doesn't exist, create an empty file
+		await fs.promises.writeFile(filePath, '')
+	}
+}

package/src/ws-server/logger.ts

@@ -0,0 +1,30 @@
+import { inspect } from 'util'
+import type { LogEntry } from '../lib/ws-message'
+
+export function createLogger(sendMessage: (msg: LogEntry) => void) {
+	const enableConsole = !!process.env.PRINT_CONSOLE
+	return {
+		log: (...args: any[]) => {
+			if (enableConsole) console.log(...args)
+			sendMessage({ message: prettyArgs(args), severity: 'INFO' })
+		},
+		debug: (...args: any[]) => {
+			if (enableConsole) console.debug(...args)
+			sendMessage({ message: prettyArgs(args), severity: 'DEBUG' })
+		},
+		error: (...args: any[]) => {
+			if (enableConsole) console.error(...args)
+			sendMessage({ message: prettyArgs(args), severity: 'ERROR' })
+		},
+		warn: (...args: any[]) => {
+			if (enableConsole) console.warn(...args)
+			sendMessage({ message: prettyArgs(args), severity: 'WARNING' })
+		}
+	}
+}
+
+function prettyArgs(args: any[]) {
+	return args
+		.map((arg) => (typeof arg === 'object' ? inspect(arg, { depth: null }) : arg))
+		.join(' ')
+}

package/src/ws-server/message-dispatcher.ts

@@ -0,0 +1,76 @@
+import type {
+	DelayedActions,
+	LogEntry,
+	AgentPayload,
+	AgentSateHeader,
+	WsMessage
+} from '../lib/ws-message'
+import { type Action, type Message } from '@recombine-ai/engine'
+import { WebSocket } from 'ws'
+
+export class MessageDispatcher {
+	constructor(private ws: WebSocket) {}
+
+	private sendWsMessage(message: WsMessage) {
+		if (message.channel === 'app-events') {
+			console.log('<-- ', message.channel, message.event.type)
+		} else if (message.channel === 'chat') {
+			console.log('<-- ', message.channel, message.message)
+		}
+		this.ws.send(JSON.stringify(message))
+	}
+
+	sendAction = (action: Action) => {
+		this.sendWsMessage({ channel: 'actions', action })
+	}
+
+	sendMessage = async (message: Message) => {
+		this.sendWsMessage({ channel: 'chat', message })
+	}
+
+	sendLog = async (message: LogEntry) => {
+		this.sendWsMessage({ channel: 'log', message })
+	}
+
+	sendSchedule = async (actions: DelayedActions) => {
+		this.sendWsMessage({
+			channel: 'app-events',
+			event: { type: 'delayed-actions-updated', actions }
+		})
+	}
+
+	sendAgentSelected = async (agent: AgentPayload) => {
+		this.sendWsMessage({
+			channel: 'app-events',
+			event: { type: 'agent-selected', agent }
+		})
+	}
+
+	sendContext = async (context: Record<string, any>) => {
+		this.sendWsMessage({
+			channel: 'app-events',
+			event: { type: 'context-updated', context }
+		})
+	}
+
+	sendPrompt = async (prompt: string) => {
+		this.sendWsMessage({
+			channel: 'app-events',
+			event: { type: 'prompt-updated', prompt }
+		})
+	}
+
+	sendLoaded = async (agents: string[]) => {
+		this.sendWsMessage({
+			channel: 'app-events',
+			event: { type: 'agents-loaded', agents }
+		})
+	}
+
+	sendUpdateStates = async (states: AgentSateHeader[]) => {
+		this.sendWsMessage({
+			channel: 'app-events',
+			event: { type: 'update-states', states }
+		})
+	}
+}

package/src/ws-server/projects.ts

@@ -0,0 +1,58 @@
+import type { TestAgentFactory } from '@recombine-ai/engine'
+import { glob } from 'glob'
+import path from 'node:path'
+import { pathToFileURL } from 'node:url'
+import { readFile } from 'node:fs/promises'
+
+export interface Project {
+	factories: Record<string, TestAgentFactory>
+	project: string
+	basePath: string
+}
+
+// TODO Drop this when all agents have bosun root
+const legacyPath = 'src/bosun/workflows.ts'
+
+export async function loadProjects() {
+	const projectRoot = process.env.BOSUN_NPX_RUN === 'true' ? process.cwd() : 'projects/*/'
+	const projectFiles = await glob(`${projectRoot}/package.json`, { absolute: true })
+	console.log('loadProjects, projectFiles: ', projectFiles)
+
+	const agentFactories: Project[] = []
+
+	for (const file of projectFiles) {
+		let pkg: any
+		try {
+			const raw = await readFile(file, 'utf8')
+			pkg = JSON.parse(raw)
+		} catch (e) {
+			console.error('Failed to read package.json:', file, e)
+			continue
+		}
+
+		const agentsRoot = pkg?.bosun?.root ?? legacyPath
+		const projectName = path.basename(path.dirname(file))
+		const agentsRootPath = path.resolve(path.dirname(file), agentsRoot)
+		const modUrl = pathToFileURL(agentsRootPath).href
+
+		let mod: any
+		try {
+			mod = await import(modUrl)
+		} catch (e) {
+			console.error('Failed to import agents module:', modUrl, e)
+			continue
+		}
+
+		const basePath = mod?.basePath ?? path.dirname(agentsRootPath)
+
+		if (projectName && mod?.default) {
+			agentFactories.push({
+				basePath,
+				project: projectName,
+				factories: mod.default as Record<string, TestAgentFactory>
+			})
+		}
+	}
+
+	return agentFactories
+}

package/src/ws-server/scheduler.ts

@@ -0,0 +1,89 @@
+import type { Logger, Scheduler, SendAction } from '@recombine-ai/engine'
+import type { DelayedActions } from '../lib/ws-message'
+
+export type DelayedActionRegistry<T> = Record<
+	string,
+	{ at: string | null; handler: (data: T) => Promise<unknown>; data: T | null }
+>
+
+export interface BosunScheduler extends Scheduler {
+	triggerAction: (actionName: string) => Promise<void>
+	serialize: () => DelayedActions
+	setState(state: DelayedActions): void
+}
+
+interface Props {
+	logger: Logger
+	sendAction: SendAction
+	onUpdate: (actions: DelayedActions) => void
+}
+export function createScheduler(
+	{ logger, sendAction, onUpdate }: Props,
+	delayedActions: DelayedActionRegistry<string> = {}
+) {
+	const scheduler: BosunScheduler = {
+		clearAllPendingActions: async () => {
+			sendAction({
+				id: Math.random().toString(),
+				type: 'Scheduler',
+				state: 'completed',
+				message: 'Clear all pending actions'
+			})
+			Object.keys(delayedActions).forEach((actionName) => {
+				delayedActions[actionName] = {
+					at: null,
+					handler: delayedActions[actionName].handler,
+					data: null
+				}
+			})
+			console.log('clearAllPendingActions')
+			onUpdate(delayedActions)
+		},
+		registerAction(actionName, handler) {
+			delayedActions[actionName] = { at: null, handler, data: null }
+			// console.log('registerAction', actionName)
+			onUpdate(delayedActions)
+			// TODO should be generic data instead of string phone
+			return async (delay, phone) => {
+				const msg = `Scheduled action "${actionName}" at ${delay.toLocaleString()}`
+				delayedActions[actionName] = { at: delay.toLocaleString(), data: phone, handler }
+				// console.log('registerAction', actionName, delay)
+				onUpdate(delayedActions)
+				logger.log(msg)
+				sendAction({
+					id: Math.random().toString(),
+					type: 'Scheduler',
+					state: 'completed',
+					message: msg
+				})
+			}
+		},
+		triggerAction: async (actionName: string) => {
+			const action = delayedActions[actionName]
+			if (!action) {
+				logger.error(`Action "${actionName}" not found`)
+				return
+			}
+			const msg = `Triggered action "${actionName}" at ${new Date().toLocaleString()}`
+			logger.log(msg)
+			delayedActions[actionName] = { at: null, handler: action.handler, data: null }
+			console.log('triggerAction', actionName)
+			onUpdate(delayedActions)
+			if (!action.data) {
+				throw new Error('Action data is missing')
+			}
+			await action.handler(action.data)
+		},
+		serialize: () => delayedActions,
+		setState: (state) => {
+			for (const key in state) {
+				const oldSchedule = delayedActions[key]
+				if (oldSchedule) {
+					delayedActions[key] = { ...oldSchedule, ...state[key] }
+				}
+			}
+			onUpdate(delayedActions)
+		}
+	}
+	return scheduler
+}

package/src/ws-server/server.ts

@@ -0,0 +1,77 @@
+import 'dotenv/config'
+import { WebSocketServer } from 'ws'
+import type { WsMessage } from '../lib/ws-message'
+import { createAgents } from './agents'
+import { fsContextPersistence, fsStatePersistence } from './fs-persistence'
+import { MessageDispatcher } from './message-dispatcher'
+import type { StepTracer } from '@recombine-ai/engine'
+
+const wss = new WebSocketServer({ port: 8080 })
+
+wss.on('connection', async (ws) => {
+	console.log('----------------- Client connected -----------------')
+
+	const stepTracer: StepTracer = {
+		addStepTrace: (stepTrace) => {
+			// TODO: client doesn't react to step traces yet - but should
+			ws.send(
+				JSON.stringify({
+					channel: 'app-events',
+					event: { type: 'step-trace', stepTrace }
+				})
+			)
+		}
+	}
+	const agents = createAgents(
+		new MessageDispatcher(ws),
+		stepTracer,
+		fsStatePersistence,
+		fsContextPersistence
+	)
+
+	agents.load()
+
+	ws.on('message', async (event) => {
+		const msg = JSON.parse(event.toString()) as WsMessage
+		// @ts-ignore
+		console.log('--> ', msg.channel, msg.event?.type || '')
+		try {
+			switch (msg.channel) {
+				case 'app-events':
+					switch (msg.event.type) {
+						case 'select-agent':
+							await agents.select(msg.event.agent, msg.event.state)
+							break
+						case 'context-updated':
+							agents.updateContext(msg.event.context)
+							break
+						case 'prompt-updated':
+							agents.updatePrompt(msg.event.prompt)
+							break
+						case 'trigger-action':
+							agents.triggerAction(msg.event.action)
+							break
+						case 'step-selected':
+							agents.selectStep(msg.event.step)
+							break
+
+						default:
+							console.error(`Unknown event type: ${msg.event.type}`)
+					}
+					break
+				case 'chat':
+					await agents.handleMessage(msg.message)
+					break
+				default:
+					console.error(`Unknown channel: ${msg.channel}`)
+			}
+		} catch (error) {
+			console.error('Error handling message', error)
+			ws.send(JSON.stringify({ channel: 'error', message: String(error) }))
+		}
+	})
+})
+
+console.log('---------------------------------------')
+console.log('WebSocket server started on ws://localhost:8080')
+console.log('---------------------------------------')

package/src/ws-server/tracer.ts

@@ -0,0 +1,11 @@
+import type { Logger, StepTraceDef } from '@recombine-ai/engine'
+
+export function createTracer(logger: Logger) {
+	const steps: StepTraceDef[] = []
+	return {
+		addStep(def: StepTraceDef) {
+			steps.push(def)
+		},
+		getSteps: () => steps
+	}
+}

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+	"extends": "./.svelte-kit/tsconfig.json",
+	"compilerOptions": {
+		"allowJs": true,
+		"checkJs": true,
+		"esModuleInterop": true,
+		"forceConsistentCasingInFileNames": true,
+		"resolveJsonModule": true,
+		"skipLibCheck": true,
+		"sourceMap": true,
+		"strict": true,
+		"moduleResolution": "bundler",
+		"types": ["svelte"],
+		"allowArbitraryExtensions": true
+	},
+	// Path aliases are handled by https://svelte.dev/docs/kit/configuration#alias
+	// except $lib which is handled by https://svelte.dev/docs/kit/configuration#files
+	//
+	// If you want to overwrite includes/excludes, make sure to copy over the relevant includes/excludes
+	// from the referenced tsconfig.json - TypeScript does not merge them in
+}