anorion 0.1.0

package/src/shared/config.ts

@@ -0,0 +1,129 @@
+import { z } from 'zod';
+import { readFileSync, existsSync } from 'fs';
+import { resolve } from 'path';
+import { parse as parseYaml } from 'yaml';
+
+const apiKeySchema = z.object({
+  name: z.string(),
+  key: z.string(),
+  scopes: z.array(z.string()).default(['*']),
+});
+
+const gatewaySchema = z.object({
+  host: z.string().default('0.0.0.0'),
+  port: z.number().default(4250),
+  apiKeys: z.array(apiKeySchema).default([]),
+  database: z.string().default('./data/anorion.db'),
+});
+
+const agentsSchema = z.object({
+  dir: z.string().default('./agents'),
+  defaultModel: z.string().default('openai/gpt-4o'),
+  defaultTimeoutMs: z.number().default(120000),
+  maxSubagents: z.number().default(5),
+  idleTimeoutMs: z.number().default(1800000),
+});
+
+const schedulerSchema = z.object({
+  enabled: z.boolean().default(true),
+});
+
+const bridgeSchema = z.object({
+  enabled: z.boolean().default(false),
+  secret: z.string().default('anorion-bridge-dev'),
+  port: z.number().default(4260),
+  peers: z.array(z.object({
+    url: z.string(),
+    secret: z.string().optional(),
+  })).default([]),
+});
+
+const memorySchema = z.object({
+  provider: z.enum(['file', 'sqlite']).default('file'),
+  directory: z.string().default('./data/memory'),
+});
+
+const telegramChannelSchema = z.object({
+  enabled: z.boolean().default(false),
+  botToken: z.string().default(''),
+  allowedUsers: z.array(z.string()).default([]),
+  defaultAgent: z.string().default('example'),
+});
+
+const webhookChannelSchema = z.object({
+  enabled: z.boolean().default(false),
+  inboundSecret: z.string().default(''),
+  outboundUrls: z.array(z.string()).default([]),
+  allowedIps: z.array(z.string()).default([]),
+});
+
+const channelsSchema = z.object({
+  telegram: telegramChannelSchema.default({} as any),
+  webhook: webhookChannelSchema.default({} as any),
+});
+
+const skillsSchema = z.object({
+  dir: z.string().default('./skills'),
+  watch: z.boolean().default(false),
+});
+
+const auditSchema = z.object({
+  enabled: z.boolean().default(true),
+  dbPath: z.string().default('./data/audit.db'),
+});
+
+const tokenBudgetSchema = z.object({
+  enabled: z.boolean().default(false),
+  sessionLimit: z.number().default(500_000),
+  dailyLimit: z.number().default(2_000_000),
+  globalDailyLimit: z.number().default(10_000_000),
+  mode: z.enum(['track', 'enforce']).default('enforce'),
+});
+
+const pipelinesSchema = z.object({
+  dir: z.string().optional(),
+});
+
+const configSchema = z.object({
+  gateway: gatewaySchema.default({} as any),
+  agents: agentsSchema.default({} as any),
+  scheduler: schedulerSchema.default({} as any),
+  bridge: bridgeSchema.default({} as any),
+  memory: memorySchema.default({} as any),
+  channels: channelsSchema.default({} as any),
+  skills: skillsSchema.default({} as any),
+  audit: auditSchema.default({} as any),
+  tokenBudget: tokenBudgetSchema.default({} as any),
+  pipelines: pipelinesSchema.default({} as any),
+});
+
+export type AnorionConfig = z.infer<typeof configSchema>;
+
+function substituteEnv(obj: unknown): unknown {
+  if (typeof obj === 'string') {
+    return obj.replace(/\$\{(\w+)(?::-([^}]*))?\}/g, (_, varName, defaultVal) => process.env[varName] || defaultVal || '');
+  }
+  if (Array.isArray(obj)) return obj.map(substituteEnv);
+  if (obj && typeof obj === 'object') {
+    const out: Record<string, unknown> = {};
+    for (const [k, v] of Object.entries(obj as Record<string, unknown>)) {
+      out[k] = substituteEnv(v);
+    }
+    return out;
+  }
+  return obj;
+}
+
+export function loadConfig(configPath?: string): AnorionConfig {
+  const path = configPath || resolve(process.cwd(), 'anorion.yaml');
+
+  if (!existsSync(path)) {
+    // Return defaults
+    return configSchema.parse({});
+  }
+
+  const raw = readFileSync(path, 'utf-8');
+  const parsed = parseYaml(raw);
+  const substituted = substituteEnv(parsed) as Record<string, unknown>;
+  return configSchema.parse(substituted);
+}

package/src/shared/db/index.ts

@@ -0,0 +1,165 @@
+import { Database } from 'bun:sqlite';
+import { drizzle } from 'drizzle-orm/bun-sqlite';
+import { resolve } from 'path';
+import { mkdirSync } from 'fs';
+import * as schema from './schema';
+import { PreparedStatements } from './prepared';
+import { logger } from '../logger';
+
+export type Db = ReturnType<typeof drizzle<typeof schema>>;
+
+export interface DatabaseResult {
+  db: Db;
+  raw: Database;
+  prepared: PreparedStatements;
+}
+
+export function initDatabase(dbPath: string): DatabaseResult {
+  const fullPath = resolve(process.cwd(), dbPath);
+  const dir = fullPath.slice(0, fullPath.lastIndexOf('/'));
+  mkdirSync(dir, { recursive: true });
+
+  const sqlite = new Database(fullPath);
+  sqlite.exec('PRAGMA journal_mode = WAL');
+  sqlite.exec('PRAGMA foreign_keys = ON');
+  sqlite.exec('PRAGMA synchronous = NORMAL');
+  sqlite.exec('PRAGMA cache_size = -20000');
+  sqlite.exec('PRAGMA temp_store = MEMORY');
+  sqlite.exec('PRAGMA mmap_size = 268435456');
+
+  const db = drizzle(sqlite, { schema });
+
+  sqlite.exec(`
+    CREATE TABLE IF NOT EXISTS agents (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL UNIQUE,
+      model TEXT NOT NULL,
+      fallback_model TEXT,
+      system_prompt TEXT NOT NULL DEFAULT 'You are a helpful assistant.',
+      tools TEXT NOT NULL DEFAULT '[]',
+      max_iterations INTEGER DEFAULT 10,
+      timeout_ms INTEGER DEFAULT 120000,
+      state TEXT NOT NULL DEFAULT 'idle',
+      tags TEXT DEFAULT '[]',
+      metadata TEXT DEFAULT '{}',
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS sessions (
+      id TEXT PRIMARY KEY,
+      agent_id TEXT NOT NULL REFERENCES agents(id) ON DELETE CASCADE,
+      channel_id TEXT,
+      status TEXT NOT NULL DEFAULT 'active',
+      tokens_used INTEGER DEFAULT 0,
+      message_count INTEGER DEFAULT 0,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+      last_active TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS messages (
+      id TEXT PRIMARY KEY,
+      session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+      agent_id TEXT NOT NULL REFERENCES agents(id),
+      role TEXT NOT NULL,
+      content TEXT NOT NULL DEFAULT '',
+      tool_calls TEXT,
+      tool_results TEXT,
+      tokens_in INTEGER,
+      tokens_out INTEGER,
+      model TEXT,
+      duration_ms INTEGER,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS tools (
+      name TEXT PRIMARY KEY,
+      description TEXT NOT NULL,
+      schema TEXT NOT NULL,
+      category TEXT DEFAULT 'system',
+      timeout_ms INTEGER DEFAULT 30000,
+      max_output_bytes INTEGER DEFAULT 1000000,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS schedules (
+      id TEXT PRIMARY KEY,
+      agent_id TEXT NOT NULL REFERENCES agents(id) ON DELETE CASCADE,
+      name TEXT NOT NULL,
+      cron_expr TEXT NOT NULL,
+      task TEXT NOT NULL,
+      enabled INTEGER DEFAULT 1,
+      last_run TEXT,
+      next_run TEXT,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS memory_entries (
+      id TEXT PRIMARY KEY,
+      agent_id TEXT NOT NULL REFERENCES agents(id) ON DELETE CASCADE,
+      key TEXT NOT NULL,
+      value TEXT NOT NULL,
+      category TEXT DEFAULT 'general',
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS api_keys (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      key_hash TEXT NOT NULL,
+      scopes TEXT NOT NULL DEFAULT '["*"]',
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    -- Existing indexes
+    CREATE INDEX IF NOT EXISTS idx_sessions_agent ON sessions(agent_id);
+    CREATE INDEX IF NOT EXISTS idx_messages_session ON messages(session_id, created_at);
+    CREATE INDEX IF NOT EXISTS idx_messages_agent ON messages(agent_id, created_at);
+    CREATE INDEX IF NOT EXISTS idx_memory_agent ON memory_entries(agent_id);
+
+    -- Missing indexes
+    CREATE INDEX IF NOT EXISTS idx_sessions_status ON sessions(status);
+    CREATE INDEX IF NOT EXISTS idx_sessions_last_active ON sessions(last_active);
+    CREATE INDEX IF NOT EXISTS idx_sessions_channel ON sessions(channel_id);
+    CREATE INDEX IF NOT EXISTS idx_schedules_agent ON schedules(agent_id);
+    CREATE INDEX IF NOT EXISTS idx_schedules_enabled ON schedules(enabled);
+    CREATE INDEX IF NOT EXISTS idx_api_keys_hash ON api_keys(key_hash);
+
+    -- Ensure unique index on (agent_id, key) for upsert support
+    DROP INDEX IF EXISTS idx_memory_agent_key;
+    CREATE UNIQUE INDEX idx_memory_agent_key ON memory_entries(agent_id, key);
+  `);
+
+  // FTS5 full-text search for memory entries (external content with sync triggers)
+  sqlite.exec(`
+    CREATE VIRTUAL TABLE IF NOT EXISTS memory_fts USING fts5(
+      key, value, category,
+      content='memory_entries',
+      content_rowid='rowid'
+    );
+
+    CREATE TRIGGER IF NOT EXISTS memory_fts_ai AFTER INSERT ON memory_entries BEGIN
+      INSERT INTO memory_fts(rowid, key, value, category)
+        VALUES (new.rowid, new.key, new.value, new.category);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS memory_fts_ad AFTER DELETE ON memory_entries BEGIN
+      INSERT INTO memory_fts(memory_fts, rowid, key, value, category)
+        VALUES ('delete', old.rowid, old.key, old.value, old.category);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS memory_fts_au AFTER UPDATE ON memory_entries BEGIN
+      INSERT INTO memory_fts(memory_fts, rowid, key, value, category)
+        VALUES ('delete', old.rowid, old.key, old.value, old.category);
+      INSERT INTO memory_fts(rowid, key, value, category)
+        VALUES (new.rowid, new.key, new.value, new.category);
+    END;
+  `);
+
+  const prepared = new PreparedStatements(sqlite);
+
+  logger.info({ path: fullPath }, 'Database initialized');
+  return { db, raw: sqlite, prepared };
+}

package/src/shared/db/prepared.ts

@@ -0,0 +1,111 @@
+import type { Database as BunDatabase, Statement } from 'bun:sqlite';
+
+/** Thin wrapper around bun:sqlite prepared statements with lazy init. */
+export class PreparedStatements {
+  // Agents
+  readonly agentInsert: Statement;
+  readonly agentUpdate: Statement;
+  readonly agentDelete: Statement;
+  readonly agentGetById: Statement;
+  readonly agentGetByName: Statement;
+
+  // Sessions
+  readonly sessionInsert: Statement;
+  readonly sessionGetById: Statement;
+  readonly sessionListByAgent: Statement;
+  readonly sessionSetStatus: Statement;
+  readonly sessionUpdateActivity: Statement;
+
+  // Messages
+  readonly messageInsert: Statement;
+  readonly messageListBySession: Statement;
+
+  // Schedules
+  readonly scheduleInsert: Statement;
+  readonly scheduleUpdate: Statement;
+  readonly scheduleDelete: Statement;
+  readonly scheduleSetLastRun: Statement;
+  readonly scheduleGetAll: Statement;
+
+  constructor(db: BunDatabase) {
+    // Agents
+    this.agentInsert = db.prepare(
+      `INSERT INTO agents (id, name, model, fallback_model, system_prompt, tools, max_iterations, timeout_ms, state, tags, metadata, created_at, updated_at)
+       VALUES ($id, $name, $model, $fallbackModel, $systemPrompt, $tools, $maxIterations, $timeoutMs, $state, $tags, $metadata, $createdAt, $updatedAt)
+       ON CONFLICT (name) DO UPDATE SET id=$id, model=$model, fallback_model=$fallbackModel, system_prompt=$systemPrompt, tools=$tools, max_iterations=$maxIterations, timeout_ms=$timeoutMs, state=$state, tags=$tags, metadata=$metadata, updated_at=$updatedAt`,
+    );
+
+    this.agentUpdate = db.prepare(
+      `UPDATE agents SET name=$name, model=$model, fallback_model=$fallbackModel, system_prompt=$systemPrompt, tools=$tools,
+        max_iterations=$maxIterations, timeout_ms=$timeoutMs, tags=$tags, metadata=$metadata, updated_at=$updatedAt
+       WHERE id = $id`,
+    );
+
+    this.agentDelete = db.prepare(
+      `DELETE FROM agents WHERE id = $id`,
+    );
+
+    this.agentGetById = db.prepare(
+      `SELECT * FROM agents WHERE id = $id`,
+    );
+
+    this.agentGetByName = db.prepare(
+      `SELECT * FROM agents WHERE name = $name`,
+    );
+
+    // Sessions
+    this.sessionInsert = db.prepare(
+      `INSERT INTO sessions (id, agent_id, channel_id, status, tokens_used, message_count, created_at, updated_at, last_active)
+       VALUES ($id, $agentId, $channelId, $status, $tokensUsed, $messageCount, $createdAt, $updatedAt, $lastActive)`,
+    );
+
+    this.sessionGetById = db.prepare(
+      `SELECT * FROM sessions WHERE id = $id`,
+    );
+
+    this.sessionListByAgent = db.prepare(
+      `SELECT * FROM sessions WHERE agent_id = $agentId ORDER BY last_active DESC`,
+    );
+
+    this.sessionSetStatus = db.prepare(
+      `UPDATE sessions SET status = $status, updated_at = $updatedAt WHERE id = $id`,
+    );
+
+    this.sessionUpdateActivity = db.prepare(
+      `UPDATE sessions SET last_active = $lastActive, updated_at = $updatedAt, tokens_used = $tokensUsed, message_count = $messageCount, status = $status
+       WHERE id = $id`,
+    );
+
+    // Messages
+    this.messageInsert = db.prepare(
+      `INSERT INTO messages (id, session_id, agent_id, role, content, tool_calls, tool_results, tokens_in, tokens_out, model, duration_ms, created_at)
+       VALUES ($id, $sessionId, $agentId, $role, $content, $toolCalls, $toolResults, $tokensIn, $tokensOut, $model, $durationMs, $createdAt)`,
+    );
+
+    this.messageListBySession = db.prepare(
+      `SELECT * FROM messages WHERE session_id = $sessionId ORDER BY created_at DESC LIMIT $limit`,
+    );
+
+    // Schedules
+    this.scheduleInsert = db.prepare(
+      `INSERT INTO schedules (id, agent_id, name, cron_expr, task, enabled, created_at)
+       VALUES ($id, $agentId, $name, $cronExpr, $task, $enabled, $createdAt)`,
+    );
+
+    this.scheduleUpdate = db.prepare(
+      `UPDATE schedules SET name=$name, cron_expr=$cronExpr, task=$task, enabled=$enabled WHERE id = $id`,
+    );
+
+    this.scheduleDelete = db.prepare(
+      `DELETE FROM schedules WHERE id = $id`,
+    );
+
+    this.scheduleSetLastRun = db.prepare(
+      `UPDATE schedules SET last_run = $lastRun WHERE id = $id`,
+    );
+
+    this.scheduleGetAll = db.prepare(
+      `SELECT * FROM schedules`,
+    );
+  }
+}

package/src/shared/db/schema.ts

@@ -0,0 +1,84 @@
+import { sqliteTable, text, integer } from 'drizzle-orm/sqlite-core';
+
+export const agents = sqliteTable('agents', {
+  id: text('id').primaryKey(),
+  name: text('name').notNull().unique(),
+  model: text('model').notNull(),
+  fallbackModel: text('fallback_model'),
+  systemPrompt: text('system_prompt').notNull().default('You are a helpful assistant.'),
+  tools: text('tools').notNull().default('[]'),
+  maxIterations: integer('max_iterations').default(10),
+  timeoutMs: integer('timeout_ms').default(120000),
+  state: text('state').notNull().default('idle'),
+  tags: text('tags').default('[]'),
+  metadata: text('metadata').default('{}'),
+  createdAt: text('created_at').notNull().default("datetime('now')"),
+  updatedAt: text('updated_at').notNull().default("datetime('now')"),
+});
+
+export const sessions = sqliteTable('sessions', {
+  id: text('id').primaryKey(),
+  agentId: text('agent_id').notNull().references(() => agents.id, { onDelete: 'cascade' }),
+  channelId: text('channel_id'),
+  status: text('status').notNull().default('active'),
+  tokensUsed: integer('tokens_used').default(0),
+  messageCount: integer('message_count').default(0),
+  createdAt: text('created_at').notNull().default("datetime('now')"),
+  updatedAt: text('updated_at').notNull().default("datetime('now')"),
+  lastActive: text('last_active').notNull().default("datetime('now')"),
+});
+
+export const messages = sqliteTable('messages', {
+  id: text('id').primaryKey(),
+  sessionId: text('session_id').notNull().references(() => sessions.id, { onDelete: 'cascade' }),
+  agentId: text('agent_id').notNull().references(() => agents.id),
+  role: text('role').notNull(),
+  content: text('content').notNull().default(''),
+  toolCalls: text('tool_calls'),
+  toolResults: text('tool_results'),
+  tokensIn: integer('tokens_in'),
+  tokensOut: integer('tokens_out'),
+  model: text('model'),
+  durationMs: integer('duration_ms'),
+  createdAt: text('created_at').notNull().default("datetime('now')"),
+});
+
+export const tools = sqliteTable('tools', {
+  name: text('name').primaryKey(),
+  description: text('description').notNull(),
+  schema: text('schema').notNull(),
+  category: text('category').default('system'),
+  timeoutMs: integer('timeout_ms').default(30000),
+  maxOutputBytes: integer('max_output_bytes').default(1000000),
+  createdAt: text('created_at').notNull().default("datetime('now')"),
+});
+
+export const schedules = sqliteTable('schedules', {
+  id: text('id').primaryKey(),
+  agentId: text('agent_id').notNull().references(() => agents.id, { onDelete: 'cascade' }),
+  name: text('name').notNull(),
+  cronExpr: text('cron_expr').notNull(),
+  task: text('task').notNull(),
+  enabled: integer('enabled', { mode: 'boolean' }).default(true),
+  lastRun: text('last_run'),
+  nextRun: text('next_run'),
+  createdAt: text('created_at').notNull().default("datetime('now')"),
+});
+
+export const memoryEntries = sqliteTable('memory_entries', {
+  id: text('id').primaryKey(),
+  agentId: text('agent_id').notNull().references(() => agents.id, { onDelete: 'cascade' }),
+  key: text('key').notNull(),
+  value: text('value').notNull(),
+  category: text('category').default('general'),
+  createdAt: text('created_at').notNull().default("datetime('now')"),
+  updatedAt: text('updated_at').notNull().default("datetime('now')"),
+});
+
+export const apiKeys = sqliteTable('api_keys', {
+  id: text('id').primaryKey(),
+  name: text('name').notNull(),
+  keyHash: text('key_hash').notNull(),
+  scopes: text('scopes').notNull().default('["*"]'),
+  createdAt: text('created_at').notNull().default("datetime('now')"),
+});

package/src/shared/events.ts

@@ -0,0 +1,79 @@
+// Simple typed pub/sub event bus for decoupled communication
+// Used by runtime → WS broadcasting, metrics, audit log, etc.
+
+type EventHandler<T = unknown> = (event: T) => void;
+
+interface EventSubscription {
+  unsubscribe: () => void;
+}
+
+class EventBus {
+  private handlers = new Map<string, Set<EventHandler>>();
+  private onceHandlers = new Map<string, Set<EventHandler>>();
+
+  on<T>(event: string, handler: EventHandler<T>): EventSubscription {
+    if (!this.handlers.has(event)) {
+      this.handlers.set(event, new Set());
+    }
+    const set = this.handlers.get(event)!;
+    const wrapped = handler as EventHandler;
+    set.add(wrapped);
+    return { unsubscribe: () => set.delete(wrapped) };
+  }
+
+  once<T>(event: string, handler: EventHandler<T>): void {
+    if (!this.onceHandlers.has(event)) {
+      this.onceHandlers.set(event, new Set());
+    }
+    this.onceHandlers.get(event)!.add(handler as EventHandler);
+  }
+
+  emit<T>(event: string, data: T): void {
+    const handlers = this.handlers.get(event);
+    if (handlers) {
+      for (const h of handlers) {
+        try { h(data); } catch { /* swallow */ }
+      }
+    }
+    const once = this.onceHandlers.get(event);
+    if (once) {
+      this.onceHandlers.delete(event);
+      for (const h of once) {
+        try { h(data); } catch { /* swallow */ }
+      }
+    }
+  }
+
+  removeAllFor(event: string): void {
+    this.handlers.delete(event);
+    this.onceHandlers.delete(event);
+  }
+
+  eventNames(): string[] {
+    return [...new Set([...this.handlers.keys(), ...this.onceHandlers.keys()])];
+  }
+}
+
+export const eventBus = new EventBus();
+
+// Typed event definitions
+export interface AgentEvents {
+  'agent:processing': { agentId: string; sessionId: string; timestamp: number };
+  'agent:tool-call': { agentId: string; sessionId: string; toolName: string; toolCallId: string; timestamp: number };
+  'agent:response': { agentId: string; sessionId: string; content: string; durationMs: number; tokensUsed?: number; timestamp: number };
+  'agent:error': { agentId: string; sessionId: string; error: string; timestamp: number };
+  'agent:idle': { agentId: string; timestamp: number };
+  'session:created': { sessionId: string; agentId: string; timestamp: number };
+  'session:destroyed': { sessionId: string; agentId: string; timestamp: number };
+  'session:idle': { sessionId: string; agentId: string; timestamp: number };
+  'tool:executed': { agentId: string; sessionId: string; toolName: string; durationMs: number; success: boolean; timestamp: number };
+  'bridge:peer:connected': { gatewayId: string; url: string; timestamp: number };
+  'bridge:peer:disconnected': { gatewayId: string; url: string; timestamp: number };
+  'bridge:message:forwarded': { gatewayId: string; targetAgentId: string; timestamp: number };
+  'memory:saved': { agentId: string; key: string; category: string; timestamp: number };
+  'memory:forgotten': { agentId: string; key: string; timestamp: number };
+  'schedule:executed': { scheduleId: string; agentId: string; success: boolean; timestamp: number };
+  'token:usage': { agentId: string; sessionId: string; model: string; promptTokens: number; completionTokens: number; timestamp: number };
+}
+
+export type EventName = keyof AgentEvents;

package/src/shared/logger.ts

@@ -0,0 +1,10 @@
+import pino from 'pino';
+
+const isDev = process.env.NODE_ENV !== 'production';
+
+export const logger = pino({
+  level: process.env.LOG_LEVEL || (isDev ? 'debug' : 'info'),
+  ...(isDev
+    ? { transport: { target: 'pino-pretty', options: { colorize: true } } }
+    : {}),
+});