@roj-ai/sdk 0.0.2

package/src/bun-platform/fs.ts

@@ -0,0 +1,50 @@
+/**
+ * Bun/Node FileSystem adapter — thin wrapper over `node:fs/promises`.
+ *
+ * Bun's `node:fs/promises` is a full-fidelity polyfill; this module is thus
+ * identical under Bun and Node runtimes.
+ */
+
+import * as fsp from 'node:fs/promises'
+import type { FileSystem } from '../platform/index.js'
+
+export function createBunFileSystem(): FileSystem {
+	return {
+		readFile: ((path: string, encoding?: 'utf-8' | 'utf8') =>
+			encoding ? fsp.readFile(path, encoding) : fsp.readFile(path)) as FileSystem['readFile'],
+
+		writeFile: (path, data) => fsp.writeFile(path, data),
+		appendFile: (path, data) => fsp.appendFile(path, data),
+
+		mkdir: async (path, options) => {
+			await fsp.mkdir(path, options)
+		},
+
+		readdir: ((path: string, options?: { withFileTypes: true }) =>
+			options?.withFileTypes
+				? fsp.readdir(path, { withFileTypes: true })
+				: fsp.readdir(path)) as FileSystem['readdir'],
+
+		stat: (path) => fsp.stat(path),
+		access: (path, mode) => fsp.access(path, mode),
+
+		unlink: (path) => fsp.unlink(path),
+		rm: (path, options) => fsp.rm(path, options),
+		cp: async (source, dest, options) => {
+			await fsp.cp(source, dest, options)
+		},
+
+		open: (path, flags) => fsp.open(path, flags),
+
+		exists: async (path) => {
+			try {
+				await fsp.access(path)
+				return true
+			} catch {
+				return false
+			}
+		},
+
+		realpath: (path) => fsp.realpath(path),
+	}
+}

package/src/bun-platform/index.ts

@@ -0,0 +1,21 @@
+/**
+ * Bun/Node platform adapter factory.
+ *
+ * Provides concrete implementations of `@roj-ai/sdk`'s Platform interface
+ * using `node:fs/promises`, `node:child_process`, and `node:os`.
+ */
+
+import { tmpdir } from 'node:os'
+import type { Platform } from '../platform/index.js'
+import { createBunFileSystem } from './fs.js'
+import { createBunProcessRunner } from './process.js'
+
+export function createBunPlatform(): Platform {
+	return {
+		fs: createBunFileSystem(),
+		process: createBunProcessRunner(),
+		tmpDir: tmpdir(),
+	}
+}
+
+export { createBunFileSystem, createBunProcessRunner }

package/src/bun-platform/process.ts

@@ -0,0 +1,25 @@
+/**
+ * Bun/Node ProcessRunner adapter — thin wrapper over `node:child_process`.
+ */
+
+import { type ChildProcess, execFile as execFileCb, spawn as nodeSpawn } from 'node:child_process'
+import { promisify } from 'node:util'
+import type { ProcessRunner } from '../platform/index.js'
+
+const execFileP = promisify(execFileCb)
+
+export function createBunProcessRunner(): ProcessRunner {
+	return {
+		async execFile(file, args, options) {
+			const { stdout, stderr } = await execFileP(file, args, options ?? {})
+			return {
+				stdout: typeof stdout === 'string' ? stdout : Buffer.from(stdout).toString(),
+				stderr: typeof stderr === 'string' ? stderr : Buffer.from(stderr).toString(),
+			}
+		},
+
+		spawn(command, args, options): ChildProcess {
+			return nodeSpawn(command, args, options ?? {})
+		},
+	}
+}

package/src/config.test.ts

@@ -0,0 +1,174 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
+import { resolve } from 'node:path'
+import { type Config, loadConfig, validateConfig } from './config.js'
+
+describe('config', () => {
+	describe('loadConfig', () => {
+		const originalEnv = { ...process.env }
+
+		afterEach(() => {
+			// Restore original env
+			process.env = { ...originalEnv }
+		})
+
+		test('loads default values', () => {
+			// Clear relevant env vars
+			delete process.env.PORT
+			delete process.env.HOST
+			delete process.env.DATA_PATH
+			delete process.env.PERSISTENCE
+			delete process.env.OPENROUTER_API_KEY
+			delete process.env.DEFAULT_MODEL
+			delete process.env.LOG_LEVEL
+			delete process.env.LOG_FORMAT
+			delete process.env.WORKER_URL
+			delete process.env.AGENT_TOKEN
+
+			const config = loadConfig()
+
+			expect(config.port).toBe(2486)
+			expect(config.host).toBe('0.0.0.0')
+			expect(config.dataPath).toBe(resolve(process.cwd(), './data'))
+			expect(config.persistence).toBe('file')
+			expect(config.openRouterApiKey).toBeUndefined()
+			expect(config.defaultModel).toBe('anthropic/claude-haiku-4.5')
+			expect(config.logLevel).toBe('info')
+			expect(config.logFormat).toBe('console')
+			expect(config.workerUrl).toBeUndefined()
+			expect(config.agentToken).toBeUndefined()
+		})
+
+		test('loads values from environment', () => {
+			process.env.PORT = '8080'
+			process.env.HOST = '127.0.0.1'
+			process.env.DATA_PATH = '/var/data'
+			process.env.PERSISTENCE = 'memory'
+			process.env.OPENROUTER_API_KEY = 'test-api-key'
+			process.env.DEFAULT_MODEL = 'gpt-4'
+			process.env.LOG_LEVEL = 'debug'
+			process.env.LOG_FORMAT = 'json'
+			process.env.WORKER_URL = 'https://worker.example.com'
+			process.env.AGENT_TOKEN = 'secret-token'
+
+			const config = loadConfig()
+
+			expect(config.port).toBe(8080)
+			expect(config.host).toBe('127.0.0.1')
+			expect(config.dataPath).toBe('/var/data')
+			expect(config.persistence).toBe('memory')
+			expect(config.openRouterApiKey).toBe('test-api-key')
+			expect(config.defaultModel).toBe('gpt-4')
+			expect(config.logLevel).toBe('debug')
+			expect(config.logFormat).toBe('json')
+			expect(config.workerUrl).toBe('https://worker.example.com')
+			expect(config.agentToken).toBe('secret-token')
+		})
+	})
+
+	describe('validateConfig', () => {
+		const validConfig: Config = {
+			port: 2486,
+			host: '0.0.0.0',
+			dataPath: './data',
+			persistence: 'file',
+			openRouterApiKey: 'test-key',
+			defaultModel: 'test-model',
+			logLevel: 'info',
+			logFormat: 'console',
+		}
+
+		test('returns no errors for valid config with API key', () => {
+			const errors = validateConfig(validConfig)
+			expect(errors).toHaveLength(0)
+		})
+
+		test('returns no errors for valid config with mock', () => {
+			const config: Config = {
+				...validConfig,
+				openRouterApiKey: undefined,
+				llmMock: () => ({
+					content: 'mock',
+					toolCalls: [],
+					finishReason: 'stop',
+					metrics: {
+						promptTokens: 0,
+						completionTokens: 0,
+						totalTokens: 0,
+						latencyMs: 0,
+						model: 'mock',
+					},
+				}),
+			}
+			const errors = validateConfig(config)
+			expect(errors).toHaveLength(0)
+		})
+
+		test('returns error when no API key and no mock', () => {
+			const config: Config = {
+				...validConfig,
+				openRouterApiKey: undefined,
+				anthropicApiKey: undefined,
+			}
+			const errors = validateConfig(config)
+			expect(errors).toContain(
+				'At least one of OPENROUTER_API_KEY or ANTHROPIC_API_KEY must be set',
+			)
+		})
+
+		test('returns error for invalid port', () => {
+			const config: Config = {
+				...validConfig,
+				port: 70000,
+			}
+			const errors = validateConfig(config)
+			expect(errors).toContain('Invalid port number: 70000')
+		})
+
+		test('returns error for negative port', () => {
+			const config: Config = {
+				...validConfig,
+				port: -1,
+			}
+			const errors = validateConfig(config)
+			expect(errors).toContain('Invalid port number: -1')
+		})
+
+		test('returns error for invalid log level', () => {
+			const config: Config = {
+				...validConfig,
+				logLevel: 'verbose' as any,
+			}
+			const errors = validateConfig(config)
+			expect(errors).toContain('Invalid log level: verbose')
+		})
+
+		test('returns error for invalid log format', () => {
+			const config: Config = {
+				...validConfig,
+				logFormat: 'text' as any,
+			}
+			const errors = validateConfig(config)
+			expect(errors).toContain('Invalid log format: text')
+		})
+
+		test('returns error for invalid persistence', () => {
+			const config: Config = {
+				...validConfig,
+				persistence: 'sqlite' as any,
+			}
+			const errors = validateConfig(config)
+			expect(errors).toContain('Invalid persistence type: sqlite')
+		})
+
+		test('accumulates multiple errors', () => {
+			const config: Config = {
+				...validConfig,
+				openRouterApiKey: undefined,
+				port: -1,
+				logLevel: 'invalid' as any,
+			}
+			const errors = validateConfig(config)
+			expect(errors.length).toBeGreaterThanOrEqual(3)
+		})
+	})
+})

package/src/config.ts

@@ -0,0 +1,103 @@
+/**
+ * Configuration for the Agent Server
+ */
+
+import { resolve } from 'node:path'
+import type { MockInferenceHandler } from './core/llm/mock.js'
+import type { LogLevel } from './lib/logger/logger.js'
+
+/**
+ * Server configuration
+ */
+export interface Config {
+	// Server
+	port: number
+	host: string
+
+	// Persistence
+	dataPath: string
+	persistence: 'file' | 'memory'
+
+	// LLM — set one or both API keys. When both are set, Anthropic handles claude-* models,
+	// OpenRouter handles everything else as fallback.
+	openRouterApiKey?: string
+	anthropicApiKey?: string
+	defaultModel?: string
+	llmMock?: MockInferenceHandler
+	/** Extended thinking token budget (Anthropic only). When set, enables thinking. */
+	thinkingBudget?: number
+
+	// LLM Logging
+	llmLoggingEnabled?: boolean
+
+	// Logging
+	logLevel: LogLevel
+	logFormat: 'console' | 'json'
+
+	// Worker connection (DO mode)
+	workerUrl?: string
+	agentToken?: string
+
+	// WebSocket configuration
+	wsReconnectBaseDelayMs?: number
+	wsReconnectMaxDelayMs?: number
+	wsHeartbeatIntervalMs?: number
+	wsHandshakeTimeoutMs?: number
+}
+
+/**
+ * Load configuration from environment variables.
+ */
+export const loadConfig = (): Config => {
+	return {
+		port: parseInt(process.env.PORT ?? '2486', 10),
+		host: process.env.HOST ?? '0.0.0.0',
+		dataPath: resolve(process.cwd(), process.env.DATA_PATH ?? './data'),
+		persistence: (process.env.PERSISTENCE ?? 'file') as 'file' | 'memory',
+		openRouterApiKey: process.env.OPENROUTER_API_KEY,
+		anthropicApiKey: process.env.ANTHROPIC_API_KEY,
+		defaultModel: process.env.DEFAULT_MODEL ?? 'anthropic/claude-haiku-4.5',
+		thinkingBudget: process.env.THINKING_BUDGET ? parseInt(process.env.THINKING_BUDGET, 10) : undefined,
+		llmLoggingEnabled: process.env.LLM_LOGGING_ENABLED !== 'false',
+		logLevel: (process.env.LOG_LEVEL ?? 'info') as LogLevel,
+		logFormat: (process.env.LOG_FORMAT ?? 'console') as 'console' | 'json',
+		workerUrl: process.env.WORKER_URL,
+		agentToken: process.env.AGENT_TOKEN,
+		wsReconnectBaseDelayMs: parseInt(process.env.WS_RECONNECT_BASE_DELAY_MS ?? '1000', 10),
+		wsReconnectMaxDelayMs: parseInt(process.env.WS_RECONNECT_MAX_DELAY_MS ?? '30000', 10),
+		wsHeartbeatIntervalMs: parseInt(process.env.WS_HEARTBEAT_INTERVAL_MS ?? '30000', 10),
+		wsHandshakeTimeoutMs: parseInt(process.env.WS_HANDSHAKE_TIMEOUT_MS ?? '10000', 10),
+	}
+}
+
+/**
+ * Validate configuration and return errors if any.
+ */
+export const validateConfig = (config: Config): string[] => {
+	const errors: string[] = []
+
+	if (!config.llmMock && !config.openRouterApiKey && !config.anthropicApiKey) {
+		errors.push('At least one of OPENROUTER_API_KEY or ANTHROPIC_API_KEY must be set')
+	}
+
+	if (config.port < 0 || config.port > 65535) {
+		errors.push(`Invalid port number: ${config.port}`)
+	}
+
+	const validLogLevels = ['debug', 'info', 'warn', 'error']
+	if (!validLogLevels.includes(config.logLevel)) {
+		errors.push(`Invalid log level: ${config.logLevel}`)
+	}
+
+	const validLogFormats = ['console', 'json']
+	if (!validLogFormats.includes(config.logFormat)) {
+		errors.push(`Invalid log format: ${config.logFormat}`)
+	}
+
+	const validPersistence = ['file', 'memory']
+	if (!validPersistence.includes(config.persistence)) {
+		errors.push(`Invalid persistence type: ${config.persistence}`)
+	}
+
+	return errors
+}