@roj-ai/sdk 0.0.2

package/src/index.ts

@@ -0,0 +1,165 @@
+/**
+ * Roj Agent Server
+ *
+ * WebSocket bridge server connecting agent framework with worker/SPA
+ */
+
+// Config
+export { loadConfig, validateConfig } from './config.js'
+export type { Config } from './config.js'
+
+// Bootstrap
+export { bootstrap, createSystemFromServices } from './bootstrap.js'
+export type { Services } from './bootstrap.js'
+
+// System
+export { createSystem } from './core/system.js'
+export type { CreateSystemOptions, System } from './core/system.js'
+
+// Lib exports
+export { FileEventStore, MemoryEventStore } from '~/core/events/index.js'
+export { MockLLMProvider, OpenRouterProvider, RequestMatchers } from '~/core/llm/index.js'
+export type { MockInferenceHandler, OpenRouterConfig } from '~/core/llm/index.js'
+export { ConsoleLogger, JsonLogger } from '~/lib/logger/index.js'
+export type { ConsoleLoggerConfig } from '~/lib/logger/index.js'
+export type { LogLevel, Logger } from '~/lib/logger/logger.js'
+
+// User config
+export { defineConfig } from './user-config.js'
+export type { RojConfig } from './user-config.js'
+
+// Transport adapters
+export { ClientAdapter, createAgentTransport, ServerAdapter } from './transport/adapter/index.js'
+export type { AgentTransportConfig, IAgentTransport, PluginNotification } from './transport/adapter/index.js'
+
+// Runtime
+export { Agent } from '~/core/agents/agent.js'
+export type { AgentConfig } from '~/core/agents/agent.js'
+export { SessionManager } from '~/core/sessions/session-manager.js'
+export type { SessionManagerOptions } from '~/core/sessions/session-manager.js'
+export { SessionStore } from '~/core/sessions/session-store.js'
+export { Session } from '~/core/sessions/session.js'
+export type { UserOutputCallback } from '~/core/sessions/session.js'
+
+// Preset builder (for defining agent presets)
+export { createOrchestrator, createPreset, defineAgent, validatePreset } from '~/core/preset/index.js'
+export type { Preset } from '~/core/preset/index.js'
+
+// Domain types (re-exported for external consumers, replacing @roj-ai/shared root exports)
+export { AgentId } from '~/core/agents/schema.js'
+export type { AgentStatus as DomainAgentStatus, ProtocolAgentStatus, ProtocolAgentStatus as AgentStatus } from '~/core/agents/schema.js'
+export { agentEvents } from '~/core/agents/state.js'
+export type { AgentPauseReason, AgentState, LLMMessage } from '~/core/agents/state.js'
+export type { DomainEvent } from '~/core/events/types.js'
+export type { FactoryEventType } from '~/core/events/types.js'
+export { isDomainEvent } from '~/core/events/types.js'
+export type { ChatMessageContentItem, LLMCallLogEntry, LLMCallMessage, ToolResultContent } from '~/core/llm/llm-log-types.js'
+export { contentToString } from '~/core/llm/llm-log-types.js'
+export { applyMiddleware, useProvider, withAnthropic, withMaxTokens, withOpenRouter, withTemperature } from '~/core/llm/middleware.js'
+export type { InferenceNext, LLMMiddleware } from '~/core/llm/middleware.js'
+export { ModelId } from '~/core/llm/schema.js'
+export type { LLMCallId } from '~/core/llm/schema.js'
+export type { InferenceCompletedEvent, InferenceFailedEvent, InferenceStartedEvent } from '~/core/llm/state.js'
+export { estimateTokens } from '~/core/llm/tokens.js'
+export { applyEvent } from '~/core/sessions/apply-event.js'
+export { selectPluginState } from '~/core/sessions/reducer.js'
+export { SessionId } from '~/core/sessions/schema.js'
+export type { SessionMetadata } from '~/core/sessions/schema.js'
+export { createSessionState, reconstructSessionState } from '~/core/sessions/state.js'
+export type { SessionState } from '~/core/sessions/state.js'
+export type { ToolCallId } from '~/core/tools/schema.js'
+export type { ToolStartedEvent } from '~/core/tools/state.js'
+export { getAgentMailbox, selectMailboxState } from '~/plugins/mailbox/query.js'
+export type { MailboxPluginState } from '~/plugins/mailbox/query.js'
+export { MessageId } from '~/plugins/mailbox/schema.js'
+export type { MailboxMessage } from '~/plugins/mailbox/schema.js'
+export type { ServiceStatus } from '~/plugins/services/schema.js'
+export { ChatMessageId } from '~/plugins/user-chat/schema.js'
+export type { AskUserInputType, AskUserInputTypeSchema, AskUserOption } from '~/plugins/user-chat/schema.js'
+export type { BuiltinEvent } from './builtin-events.js'
+
+// Chat message types (re-exported for external consumers)
+export type { AgentChatMessage, AskUserChatMessage, ChatMessage, UserChatMessage } from '~/plugins/user-chat/index.js'
+
+// Plugins
+export { agentStatusPlugin } from '~/plugins/agent-status/plugin.js'
+export { agentsPlugin } from '~/plugins/agents/plugin.js'
+export type { AgentsPluginConfig } from '~/plugins/agents/plugin.js'
+export { contextCompactPlugin } from '~/plugins/context-compact/plugin.js'
+export type { ContextCompactPluginConfig } from '~/plugins/context-compact/plugin.js'
+export { limitsGuardPlugin, selectAgentCounters } from '~/plugins/limits-guard/plugin.js'
+export type { AgentCounters, LimitsAgentConfig } from '~/plugins/limits-guard/plugin.js'
+export type { AgentLimits } from '~/plugins/limits-guard/config.js'
+export { mailboxPlugin } from '~/plugins/mailbox/plugin.js'
+export type { MailboxAgentConfig, MailboxPresetConfig } from '~/plugins/mailbox/plugin.js'
+export { resultEvictionPlugin } from '~/plugins/result-eviction/plugin.js'
+export type { EvictionAgentConfig, EvictionConfig } from '~/plugins/result-eviction/plugin.js'
+export { servicePlugin } from '~/plugins/services/plugin.js'
+export type { ServiceAgentConfig, ServiceStatusChangedEvent } from '~/plugins/services/plugin.js'
+export { sessionStatePlugin } from '~/plugins/session-state/plugin.js'
+export type { SessionStatePluginConfig } from '~/plugins/session-state/plugin.js'
+export { presetsPlugin, sessionLifecyclePlugin } from '~/plugins/session-lifecycle/plugin.js'
+export { selectAgentSkills, skillsPlugin } from '~/plugins/skills/plugin.js'
+export type { SkillsAgentConfig, SkillsPluginConfig } from '~/plugins/skills/plugin.js'
+export type { SkillLoadedEvent } from '~/plugins/skills/plugin.js'
+export type { LoadedSkill } from '~/plugins/skills/schema.js'
+export { todoPlugin } from '~/plugins/todo/plugin.js'
+export type { TodoAgentConfig, TodoPresetConfig } from '~/plugins/todo/plugin.js'
+export { resourcesPlugin } from '~/plugins/resources/plugin.js'
+export type { ResourcesPluginConfig } from '~/plugins/resources/plugin.js'
+export { postInjectRules } from '~/plugins/resources/post-inject.js'
+export type {
+	PostInjectContext,
+	PostInjectExecOptions,
+	PostInjectHook,
+	PostInjectRule,
+} from '~/plugins/resources/post-inject.js'
+export { RESOURCE_MANIFEST_FILENAME, ResourceManifestSchema } from '~/plugins/resources/manifest.js'
+export type { ResourceManifest } from '~/plugins/resources/manifest.js'
+export { uploadsPlugin } from '~/plugins/uploads/plugin.js'
+export { userChatPlugin } from '~/plugins/user-chat/plugin.js'
+export type { UserChatAgentConfig, UserChatPresetConfig, UserCommunicationMode } from '~/plugins/user-chat/plugin.js'
+
+// Workers plugin
+export { workerPlugin } from '~/plugins/workers/index.js'
+export type { WorkerAgentConfig, WorkerPresetConfig } from '~/plugins/workers/index.js'
+export type { WorkerDefinition } from '~/plugins/workers/index.js'
+export { createWorkerDefinition } from '~/plugins/workers/index.js'
+export type { WorkerContext } from '~/plugins/workers/index.js'
+export type { WorkerError, WorkerResult } from '~/plugins/workers/index.js'
+
+// Plugin builder
+export { definePlugin } from '~/core/plugins/plugin-builder.js'
+export type { CallerContext, ConfiguredPlugin, PluginDefinition } from '~/core/plugins/plugin-builder.js'
+
+// Zod (re-export for presets that need schemas)
+export { default as z } from 'zod/v4'
+
+// Result utilities
+export { Err, Ok } from '~/lib/utils/result.js'
+export type { Result } from '~/lib/utils/result.js'
+
+// File store
+export type { FileEntry, FileStore } from '~/core/file-store/types.js'
+
+// Service config
+export { PortPool } from '~/plugins/services/port-pool.js'
+export type { ServiceCommandArgs, ServiceConfig } from '~/plugins/services/schema.js'
+
+// Session environment
+export type { SessionEnvironment } from '~/core/sessions/session-environment.js'
+
+// Platform adapters (host-environment abstractions — filesystem, process)
+// Interfaces only; concrete impls (createBunPlatform) live in @roj-ai/sdk/bun-platform.
+export type {
+	ChildProcess,
+	Dirent,
+	ExecFileOptions,
+	ExecFileResult,
+	FileHandle,
+	FileSystem,
+	Platform,
+	ProcessRunner,
+	SpawnOptions,
+	Stats,
+} from '~/platform/index.js'

package/src/lib/json/index.ts

@@ -0,0 +1,20 @@
+// ============================================================================
+// JSON Schema
+// ============================================================================
+
+/**
+ * JSON Schema type (simplified for tool parameters)
+ *
+ * Note: Index signature included for compatibility with LLM SDK types
+ * (e.g., OpenRouter SDK's ToolDefinitionJsonFunction.parameters)
+ */
+export interface JSONSchema {
+	type: 'object' | 'string' | 'number' | 'boolean' | 'array'
+	properties?: Record<string, JSONSchema>
+	items?: JSONSchema
+	required?: string[]
+	description?: string
+	enum?: string[]
+	/** Additional schema properties for extensibility */
+	[key: string]: unknown
+}

package/src/lib/logger/console.test.ts

@@ -0,0 +1,348 @@
+import { afterEach, beforeEach, describe, expect, it, Mock, spyOn } from 'bun:test'
+import { ConsoleLogger, JsonLogger } from './console.js'
+import type { Logger } from './logger.js'
+
+describe('ConsoleLogger', () => {
+	let consoleSpy: {
+		log: Mock<typeof console.log>
+		warn: Mock<typeof console.warn>
+		error: Mock<typeof console.error>
+	}
+
+	beforeEach(() => {
+		consoleSpy = {
+			log: spyOn(console, 'log').mockImplementation(() => {}),
+			warn: spyOn(console, 'warn').mockImplementation(() => {}),
+			error: spyOn(console, 'error').mockImplementation(() => {}),
+		}
+	})
+
+	afterEach(() => {
+		consoleSpy.log.mockRestore()
+		consoleSpy.warn.mockRestore()
+		consoleSpy.error.mockRestore()
+	})
+
+	describe('log level filtering', () => {
+		it('should log messages at or above configured level', () => {
+			const logger = new ConsoleLogger({ level: 'info', colors: false, timestamps: false })
+
+			logger.debug('debug message')
+			logger.info('info message')
+			logger.warn('warn message')
+			logger.error('error message')
+
+			// debug should be filtered out (use content-based assertions to avoid flakiness from concurrent test files)
+			expect(consoleSpy.log).not.toHaveBeenCalledWith(expect.stringContaining('DEBUG'))
+			expect(consoleSpy.log).toHaveBeenCalledWith('INFO  info message')
+			expect(consoleSpy.warn).toHaveBeenCalledWith('WARN  warn message')
+			expect(consoleSpy.error).toHaveBeenCalledWith('ERROR error message')
+		})
+
+		it('should log all messages at debug level', () => {
+			const logger = new ConsoleLogger({ level: 'debug', colors: false, timestamps: false })
+
+			logger.debug('debug message')
+			logger.info('info message')
+			logger.warn('warn message')
+			logger.error('error message')
+
+			expect(consoleSpy.log).toHaveBeenCalledWith('DEBUG debug message')
+			expect(consoleSpy.log).toHaveBeenCalledWith('INFO  info message')
+			expect(consoleSpy.warn).toHaveBeenCalledWith('WARN  warn message')
+			expect(consoleSpy.error).toHaveBeenCalledWith('ERROR error message')
+		})
+
+		it('should only log errors at error level', () => {
+			const logger = new ConsoleLogger({ level: 'error', colors: false, timestamps: false })
+
+			logger.debug('debug message')
+			logger.info('info message')
+			logger.warn('warn message')
+			logger.error('error message')
+
+			expect(consoleSpy.log).not.toHaveBeenCalledWith(expect.stringContaining('DEBUG'))
+			expect(consoleSpy.log).not.toHaveBeenCalledWith(expect.stringContaining('INFO'))
+			expect(consoleSpy.warn).not.toHaveBeenCalledWith(expect.stringContaining('WARN'))
+			expect(consoleSpy.error).toHaveBeenCalledWith('ERROR error message')
+		})
+	})
+
+	describe('message formatting', () => {
+		it('should format message without context', () => {
+			const logger = new ConsoleLogger({ level: 'info', colors: false, timestamps: false })
+
+			logger.info('test message')
+
+			expect(consoleSpy.log).toHaveBeenCalledWith('INFO  test message')
+		})
+
+		it('should format message with context', () => {
+			const logger = new ConsoleLogger({ level: 'info', colors: false, timestamps: false })
+
+			logger.info('test message', { key: 'value', num: 42 })
+
+			expect(consoleSpy.log).toHaveBeenCalledWith('INFO  test message { key=value num=42 }')
+		})
+
+		it('should format message with object context', () => {
+			const logger = new ConsoleLogger({ level: 'info', colors: false, timestamps: false })
+
+			logger.info('test message', { data: { nested: true } })
+
+			expect(consoleSpy.log).toHaveBeenCalledWith('INFO  test message { data={"nested":true} }')
+		})
+
+		it('should include timestamps when enabled', () => {
+			const logger = new ConsoleLogger({ level: 'info', colors: false, timestamps: true })
+
+			logger.info('test message')
+
+			const call = consoleSpy.log.mock.calls[0][0] as string
+			expect(call).toMatch(/^\[\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3}Z\] INFO {2}test message$/)
+		})
+
+		it('should use correct console method for each level', () => {
+			const logger = new ConsoleLogger({ level: 'debug', colors: false, timestamps: false })
+
+			logger.debug('debug')
+			logger.info('info')
+			logger.warn('warn')
+			logger.error('error')
+
+			expect(consoleSpy.log).toHaveBeenCalledWith('DEBUG debug')
+			expect(consoleSpy.log).toHaveBeenCalledWith('INFO  info')
+			expect(consoleSpy.warn).toHaveBeenCalledWith('WARN  warn')
+			expect(consoleSpy.error).toHaveBeenCalledWith('ERROR error')
+		})
+	})
+
+	describe('error handling', () => {
+		it('should include error details in context', () => {
+			const logger = new ConsoleLogger({ level: 'error', colors: false, timestamps: false })
+			const error = new Error('Something went wrong')
+
+			logger.error('operation failed', error)
+
+			const call = consoleSpy.error.mock.calls[0][0] as string
+			expect(call).toContain('ERROR operation failed')
+			expect(call).toContain('error={"name":"Error","message":"Something went wrong"')
+			expect(call).toContain('stack')
+		})
+
+		it('should merge error with existing context', () => {
+			const logger = new ConsoleLogger({ level: 'error', colors: false, timestamps: false })
+			const error = new Error('test error')
+
+			logger.error('operation failed', error, { userId: '123' })
+
+			const call = consoleSpy.error.mock.calls[0][0] as string
+			expect(call).toContain('userId=123')
+			expect(call).toContain('error=')
+		})
+	})
+
+	describe('child loggers', () => {
+		it('should create child logger with inherited config', () => {
+			const logger = new ConsoleLogger({ level: 'info', colors: false, timestamps: false })
+			const child = logger.child({ component: 'test' })
+
+			expect(child.level).toBe('info')
+		})
+
+		it('should include parent context in child logs', () => {
+			const logger = new ConsoleLogger({ level: 'info', colors: false, timestamps: false }, { app: 'roj' })
+			const child = logger.child({ component: 'test' })
+
+			child.info('hello')
+
+			expect(consoleSpy.log).toHaveBeenCalledWith('INFO  hello { app=roj component=test }')
+		})
+
+		it('should merge child context with message context', () => {
+			const logger = new ConsoleLogger({ level: 'info', colors: false, timestamps: false })
+			const child = logger.child({ component: 'test' })
+
+			child.info('hello', { extra: 'data' })
+
+			expect(consoleSpy.log).toHaveBeenCalledWith('INFO  hello { component=test extra=data }')
+		})
+
+		it('should allow nested child loggers', () => {
+			const logger = new ConsoleLogger({ level: 'info', colors: false, timestamps: false })
+			const child1 = logger.child({ level1: 'a' })
+			const child2 = child1.child({ level2: 'b' })
+
+			child2.info('nested')
+
+			expect(consoleSpy.log).toHaveBeenCalledWith('INFO  nested { level1=a level2=b }')
+		})
+	})
+
+	describe('colors', () => {
+		it('should include ANSI colors when enabled', () => {
+			const logger = new ConsoleLogger({ level: 'info', colors: true, timestamps: false })
+
+			logger.info('colored message')
+
+			const call = consoleSpy.log.mock.calls[0][0] as string
+			expect(call).toContain('\x1b[32m') // green
+			expect(call).toContain('\x1b[0m') // reset
+		})
+
+		it('should not include colors when disabled', () => {
+			const logger = new ConsoleLogger({ level: 'info', colors: false, timestamps: false })
+
+			logger.info('plain message')
+
+			const call = consoleSpy.log.mock.calls[0][0] as string
+			expect(call).not.toContain('\x1b[')
+		})
+	})
+})
+
+describe('JsonLogger', () => {
+	let consoleSpy: {
+		log: Mock<typeof console.log>
+		warn: Mock<typeof console.warn>
+		error: Mock<typeof console.error>
+	}
+
+	beforeEach(() => {
+		consoleSpy = {
+			log: spyOn(console, 'log').mockImplementation(() => {}),
+			warn: spyOn(console, 'warn').mockImplementation(() => {}),
+			error: spyOn(console, 'error').mockImplementation(() => {}),
+		}
+	})
+
+	afterEach(() => {
+		consoleSpy.log.mockRestore()
+		consoleSpy.warn.mockRestore()
+		consoleSpy.error.mockRestore()
+	})
+
+	describe('log level filtering', () => {
+		it('should filter messages below configured level', () => {
+			const logger = new JsonLogger('warn')
+
+			logger.debug('debug')
+			logger.info('info')
+			logger.warn('warn')
+			logger.error('error')
+
+			expect(consoleSpy.log).toHaveBeenCalledTimes(0)
+			expect(consoleSpy.warn).toHaveBeenCalledTimes(1)
+			expect(consoleSpy.error).toHaveBeenCalledTimes(1)
+		})
+	})
+
+	describe('JSON output', () => {
+		it('should output valid JSON', () => {
+			const logger = new JsonLogger('info')
+
+			logger.info('test message')
+
+			const call = consoleSpy.log.mock.calls[0][0] as string
+			const parsed = JSON.parse(call)
+			expect(parsed).toBeDefined()
+		})
+
+		it('should include all required fields', () => {
+			const logger = new JsonLogger('info')
+
+			logger.info('test message')
+
+			const call = consoleSpy.log.mock.calls[0][0] as string
+			const parsed = JSON.parse(call)
+			expect(parsed.timestamp).toMatch(/^\d{4}-\d{2}-\d{2}T/)
+			expect(parsed.level).toBe('info')
+			expect(parsed.message).toBe('test message')
+		})
+
+		it('should include context in JSON output', () => {
+			const logger = new JsonLogger('info')
+
+			logger.info('test message', { key: 'value', count: 5 })
+
+			const call = consoleSpy.log.mock.calls[0][0] as string
+			const parsed = JSON.parse(call)
+			expect(parsed.key).toBe('value')
+			expect(parsed.count).toBe(5)
+		})
+
+		it('should use correct console method for each level', () => {
+			const logger = new JsonLogger('debug')
+
+			logger.debug('debug')
+			logger.info('info')
+			logger.warn('warn')
+			logger.error('error')
+
+			expect(consoleSpy.log).toHaveBeenCalledTimes(2) // debug + info
+			expect(consoleSpy.warn).toHaveBeenCalledTimes(1)
+			expect(consoleSpy.error).toHaveBeenCalledTimes(1)
+		})
+	})
+
+	describe('error handling', () => {
+		it('should include error in JSON output', () => {
+			const logger = new JsonLogger('error')
+			const error = new Error('test error')
+
+			logger.error('failed', error)
+
+			const call = consoleSpy.error.mock.calls[0][0] as string
+			const parsed = JSON.parse(call)
+			expect(parsed.error.name).toBe('Error')
+			expect(parsed.error.message).toBe('test error')
+			expect(parsed.error.stack).toBeDefined()
+		})
+
+		it('should merge error with context', () => {
+			const logger = new JsonLogger('error')
+			const error = new Error('test error')
+
+			logger.error('failed', error, { requestId: 'abc' })
+
+			const call = consoleSpy.error.mock.calls[0][0] as string
+			const parsed = JSON.parse(call)
+			expect(parsed.requestId).toBe('abc')
+			expect(parsed.error).toBeDefined()
+		})
+	})
+
+	describe('child loggers', () => {
+		it('should create child logger with inherited level', () => {
+			const logger = new JsonLogger('warn')
+			const child = logger.child({ service: 'test' })
+
+			expect(child.level).toBe('warn')
+		})
+
+		it('should include base context in child logs', () => {
+			const logger = new JsonLogger('info', { app: 'roj' })
+			const child = logger.child({ component: 'auth' })
+
+			child.info('test')
+
+			const call = consoleSpy.log.mock.calls[0][0] as string
+			const parsed = JSON.parse(call)
+			expect(parsed.app).toBe('roj')
+			expect(parsed.component).toBe('auth')
+		})
+
+		it('should allow nested child loggers', () => {
+			const logger = new JsonLogger('info')
+			const child1 = logger.child({ a: 1 })
+			const child2 = child1.child({ b: 2 })
+
+			child2.info('nested')
+
+			const call = consoleSpy.log.mock.calls[0][0] as string
+			const parsed = JSON.parse(call)
+			expect(parsed.a).toBe(1)
+			expect(parsed.b).toBe(2)
+		})
+	})
+})