@timmeck/brain-core 1.0.0 → 1.2.0

package/src/api/server.ts

@@ -1,210 +0,0 @@
-import http from 'node:http';
-import { getLogger } from '../utils/logger.js';
-import type { IpcRouter } from '../ipc/server.js';
-
-export interface ApiServerOptions {
-  port: number;
-  router: IpcRouter;
-  apiKey?: string;
-}
-
-export interface RouteDefinition {
-  method: string;
-  pattern: RegExp;
-  ipcMethod: string;
-  extractParams: (match: RegExpMatchArray, query: URLSearchParams, body?: unknown) => unknown;
-}
-
-export class BaseApiServer {
-  private server: http.Server | null = null;
-  protected logger = getLogger();
-  private routes: RouteDefinition[];
-  protected sseClients: Set<http.ServerResponse> = new Set();
-
-  constructor(protected options: ApiServerOptions) {
-    this.routes = this.buildRoutes();
-  }
-
-  start(): void {
-    const { port, apiKey } = this.options;
-
-    this.server = http.createServer((req, res) => {
-      res.setHeader('Access-Control-Allow-Origin', '*');
-      res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
-      res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization, X-API-Key');
-
-      if (req.method === 'OPTIONS') {
-        res.writeHead(204);
-        res.end();
-        return;
-      }
-
-      if (apiKey) {
-        const provided = (req.headers['x-api-key'] as string) ??
-          req.headers.authorization?.replace('Bearer ', '');
-        if (provided !== apiKey) {
-          this.json(res, 401, { error: 'Unauthorized', message: 'Invalid or missing API key' });
-          return;
-        }
-      }
-
-      this.handleRequest(req, res).catch((err) => {
-        this.logger.error('API error:', err);
-        this.json(res, 500, {
-          error: 'Internal Server Error',
-          message: err instanceof Error ? err.message : String(err),
-        });
-      });
-    });
-
-    this.server.listen(port, () => {
-      this.logger.info(`REST API server started on http://localhost:${port}`);
-    });
-  }
-
-  stop(): void {
-    for (const client of this.sseClients) {
-      try { client.end(); } catch { /* ignore */ }
-    }
-    this.sseClients.clear();
-    this.server?.close();
-    this.server = null;
-    this.logger.info('REST API server stopped');
-  }
-
-  /** Override to add domain-specific RESTful routes */
-  protected buildRoutes(): RouteDefinition[] {
-    return [];
-  }
-
-  private async handleRequest(req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {
-    const url = new URL(req.url ?? '/', 'http://localhost');
-    const pathname = url.pathname;
-    const method = req.method ?? 'GET';
-    const query = url.searchParams;
-
-    // Health check
-    if (pathname === '/api/v1/health') {
-      this.json(res, 200, { status: 'ok', timestamp: new Date().toISOString() });
-      return;
-    }
-
-    // SSE event stream
-    if (pathname === '/api/v1/events' && method === 'GET') {
-      res.writeHead(200, {
-        'Content-Type': 'text/event-stream',
-        'Cache-Control': 'no-cache',
-        'Connection': 'keep-alive',
-      });
-      res.write('data: {"type":"connected"}\n\n');
-      this.sseClients.add(res);
-      req.on('close', () => this.sseClients.delete(res));
-      return;
-    }
-
-    // List all available methods
-    if (pathname === '/api/v1/methods' && method === 'GET') {
-      const methods = this.options.router.listMethods();
-      this.json(res, 200, {
-        methods,
-        rpcEndpoint: '/api/v1/rpc',
-        usage: 'POST /api/v1/rpc with body { "method": "<method>", "params": {...} }',
-      });
-      return;
-    }
-
-    // Generic RPC endpoint
-    if (pathname === '/api/v1/rpc' && method === 'POST') {
-      const body = await this.readBody(req);
-      if (!body) {
-        this.json(res, 400, { error: 'Bad Request', message: 'Empty request body' });
-        return;
-      }
-
-      const parsed = JSON.parse(body);
-
-      // Batch RPC support
-      if (Array.isArray(parsed)) {
-        const results = parsed.map((call: { method: string; params?: unknown; id?: string | number }) => {
-          try {
-            const result = this.options.router.handle(call.method, call.params ?? {});
-            return { id: call.id, result };
-          } catch (err) {
-            return { id: call.id, error: err instanceof Error ? err.message : String(err) };
-          }
-        });
-        this.json(res, 200, results);
-        return;
-      }
-
-      if (!parsed.method) {
-        this.json(res, 400, { error: 'Bad Request', message: 'Missing "method" field' });
-        return;
-      }
-
-      try {
-        const result = this.options.router.handle(parsed.method, parsed.params ?? {});
-        this.json(res, 200, { result });
-      } catch (err) {
-        this.json(res, 400, { error: err instanceof Error ? err.message : String(err) });
-      }
-      return;
-    }
-
-    // RESTful routes
-    let body: unknown = undefined;
-    if (method === 'POST' || method === 'PUT') {
-      try {
-        const raw = await this.readBody(req);
-        body = raw ? JSON.parse(raw) : {};
-      } catch {
-        this.json(res, 400, { error: 'Bad Request', message: 'Invalid JSON body' });
-        return;
-      }
-    }
-
-    for (const route of this.routes) {
-      if (route.method !== method) continue;
-      const match = pathname.match(route.pattern);
-      if (!match) continue;
-
-      try {
-        const params = route.extractParams(match, query, body);
-        const result = this.options.router.handle(route.ipcMethod, params);
-        this.json(res, method === 'POST' ? 201 : 200, { result });
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        const status = msg.startsWith('Unknown method') ? 404 : 400;
-        this.json(res, status, { error: msg });
-      }
-      return;
-    }
-
-    this.json(res, 404, { error: 'Not Found', message: `No route for ${method} ${pathname}` });
-  }
-
-  protected json(res: http.ServerResponse, status: number, data: unknown): void {
-    res.writeHead(status, { 'Content-Type': 'application/json' });
-    res.end(JSON.stringify(data));
-  }
-
-  protected readBody(req: http.IncomingMessage): Promise<string> {
-    return new Promise((resolve, reject) => {
-      const chunks: Buffer[] = [];
-      req.on('data', (chunk: Buffer) => chunks.push(chunk));
-      req.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
-      req.on('error', reject);
-    });
-  }
-
-  protected broadcastSSE(data: unknown): void {
-    const msg = `data: ${JSON.stringify(data)}\n\n`;
-    for (const client of this.sseClients) {
-      try {
-        client.write(msg);
-      } catch {
-        this.sseClients.delete(client);
-      }
-    }
-  }
-}

package/src/cli/colors.ts

@@ -1,105 +0,0 @@
-import chalk from 'chalk';
-
-// Shared brand color palette — identical across all brains
-export const c = {
-  // Primary palette
-  blue: chalk.hex('#5b9cff'),
-  purple: chalk.hex('#b47aff'),
-  cyan: chalk.hex('#47e5ff'),
-  green: chalk.hex('#3dffa0'),
-  red: chalk.hex('#ff5577'),
-  orange: chalk.hex('#ffb347'),
-  dim: chalk.hex('#8b8fb0'),
-  dimmer: chalk.hex('#4a4d6e'),
-
-  // Semantic
-  label: chalk.hex('#8b8fb0'),
-  value: chalk.white.bold,
-  heading: chalk.hex('#5b9cff').bold,
-  success: chalk.hex('#3dffa0').bold,
-  error: chalk.hex('#ff5577').bold,
-  warn: chalk.hex('#ffb347').bold,
-  info: chalk.hex('#47e5ff'),
-};
-
-// Shared base icons — each brain extends with domain-specific icons
-export const baseIcons = {
-  check: '\u2713',
-  cross: '\u2717',
-  arrow: '\u2192',
-  dot: '\u25CF',
-  circle: '\u25CB',
-  bar: '\u2588',
-  barLight: '\u2591',
-  dash: '\u2500',
-  pipe: '\u2502',
-  corner: '\u2514',
-  tee: '\u251C',
-  star: '\u2605',
-  bolt: '\u26A1',
-  gear: '\u2699',
-  chart: '\uD83D\uDCCA',
-  synapse: '\uD83D\uDD17',
-  insight: '\uD83D\uDCA1',
-  warn: '\u26A0',
-  error: '\u274C',
-  ok: '\u2705',
-  clock: '\u23F1',
-};
-
-export function header(title: string, icon?: string): string {
-  const prefix = icon ? `${icon}  ` : '';
-  const line = c.dimmer(baseIcons.dash.repeat(40));
-  return `\n${line}\n${prefix}${c.heading(title)}\n${line}`;
-}
-
-export function keyValue(key: string, value: string | number, indent = 2): string {
-  const pad = ' '.repeat(indent);
-  return `${pad}${c.label(key + ':')} ${c.value(String(value))}`;
-}
-
-export function statusBadge(status: string): string {
-  switch (status.toLowerCase()) {
-    case 'resolved':
-    case 'active':
-    case 'running':
-      return c.green(`[${status.toUpperCase()}]`);
-    case 'open':
-    case 'unresolved':
-      return c.red(`[${status.toUpperCase()}]`);
-    case 'warning':
-      return c.warn(`[${status.toUpperCase()}]`);
-    default:
-      return c.dim(`[${status.toUpperCase()}]`);
-  }
-}
-
-export function progressBar(current: number, total: number, width = 20): string {
-  const pct = Math.min(1, current / Math.max(1, total));
-  const filled = Math.round(pct * width);
-  const empty = width - filled;
-  return c.cyan(baseIcons.bar.repeat(filled)) + c.dimmer(baseIcons.barLight.repeat(empty));
-}
-
-export function divider(width = 40): string {
-  return c.dimmer(baseIcons.dash.repeat(width));
-}
-
-export function table(rows: string[][], colWidths?: number[]): string {
-  if (rows.length === 0) return '';
-  const widths = colWidths ?? rows[0].map((_, i) =>
-    Math.max(...rows.map(r => stripAnsi(r[i] ?? '').length))
-  );
-  return rows.map(row =>
-    row.map((cell, i) => {
-      const stripped = stripAnsi(cell);
-      const pad = Math.max(0, (widths[i] ?? stripped.length) - stripped.length);
-      return cell + ' '.repeat(pad);
-    }).join('  ')
-  ).join('\n');
-}
-
-export function stripAnsi(str: string): string {
-  // eslint-disable-next-line no-control-regex
-  return str.replace(/\x1b\[[0-9;]*m/g, '');
-}

package/src/db/connection.ts

@@ -1,22 +0,0 @@
-import Database from 'better-sqlite3';
-import fs from 'node:fs';
-import path from 'node:path';
-import { getLogger } from '../utils/logger.js';
-
-export function createConnection(dbPath: string): Database.Database {
-  const logger = getLogger();
-  const dir = path.dirname(dbPath);
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
-  }
-
-  logger.info(`Opening database at ${dbPath}`);
-  const db = new Database(dbPath);
-
-  db.pragma('journal_mode = WAL');
-  db.pragma('synchronous = NORMAL');
-  db.pragma('cache_size = 10000');
-  db.pragma('foreign_keys = ON');
-
-  return db;
-}

package/src/index.ts

@@ -1,31 +0,0 @@
-// ── Types ──────────────────────────────────────────────────
-export type { IpcMessage } from './types/ipc.types.js';
-
-// ── Utils ──────────────────────────────────────────────────
-export { sha256 } from './utils/hash.js';
-export { createLogger, getLogger, resetLogger } from './utils/logger.js';
-export type { LoggerOptions } from './utils/logger.js';
-export { normalizePath, getDataDir, getPipeName } from './utils/paths.js';
-export { TypedEventBus } from './utils/events.js';
-
-// ── DB ─────────────────────────────────────────────────────
-export { createConnection } from './db/connection.js';
-
-// ── IPC ────────────────────────────────────────────────────
-export { encodeMessage, MessageDecoder } from './ipc/protocol.js';
-export { IpcServer } from './ipc/server.js';
-export type { IpcRouter } from './ipc/server.js';
-export { IpcClient } from './ipc/client.js';
-
-// ── MCP ────────────────────────────────────────────────────
-export { startMcpServer } from './mcp/server.js';
-export type { McpServerOptions } from './mcp/server.js';
-export { McpHttpServer } from './mcp/http-server.js';
-export type { McpHttpServerOptions } from './mcp/http-server.js';
-
-// ── CLI ────────────────────────────────────────────────────
-export { c, baseIcons, header, keyValue, statusBadge, progressBar, divider, table, stripAnsi } from './cli/colors.js';
-
-// ── API ────────────────────────────────────────────────────
-export { BaseApiServer } from './api/server.js';
-export type { ApiServerOptions, RouteDefinition } from './api/server.js';

package/src/ipc/client.ts

@@ -1,117 +0,0 @@
-import net from 'node:net';
-import { randomUUID } from 'node:crypto';
-import type { IpcMessage } from '../types/ipc.types.js';
-import { encodeMessage, MessageDecoder } from './protocol.js';
-import { getPipeName } from '../utils/paths.js';
-
-interface PendingRequest {
-  resolve: (result: unknown) => void;
-  reject: (err: Error) => void;
-  timer: ReturnType<typeof setTimeout>;
-}
-
-export class IpcClient {
-  private socket: net.Socket | null = null;
-  private decoder = new MessageDecoder();
-  private pending = new Map<string, PendingRequest>();
-  private onNotification?: (msg: IpcMessage) => void;
-
-  constructor(
-    private pipeName: string = getPipeName(),
-    private timeout: number = 5000,
-  ) {}
-
-  connect(): Promise<void> {
-    return new Promise((resolve, reject) => {
-      this.socket = net.createConnection(this.pipeName, () => {
-        resolve();
-      });
-
-      this.socket.on('data', (chunk) => {
-        const messages = this.decoder.feed(chunk);
-        for (const msg of messages) {
-          this.handleMessage(msg);
-        }
-      });
-
-      this.socket.on('error', (err) => {
-        reject(err);
-        for (const [id, req] of this.pending) {
-          clearTimeout(req.timer);
-          req.reject(new Error(`Connection error: ${err.message}`));
-          this.pending.delete(id);
-        }
-      });
-
-      this.socket.on('close', () => {
-        for (const [id, req] of this.pending) {
-          clearTimeout(req.timer);
-          req.reject(new Error('Connection closed'));
-          this.pending.delete(id);
-        }
-        this.socket = null;
-      });
-    });
-  }
-
-  request(method: string, params?: unknown): Promise<unknown> {
-    return new Promise((resolve, reject) => {
-      if (!this.socket || this.socket.destroyed) {
-        return reject(new Error('Not connected'));
-      }
-
-      const id = randomUUID();
-      const timer = setTimeout(() => {
-        this.pending.delete(id);
-        reject(new Error(`Request timeout: ${method} (${this.timeout}ms)`));
-      }, this.timeout);
-
-      this.pending.set(id, { resolve, reject, timer });
-
-      const msg: IpcMessage = {
-        id,
-        type: 'request',
-        method,
-        params,
-      };
-      this.socket.write(encodeMessage(msg));
-    });
-  }
-
-  setNotificationHandler(handler: (msg: IpcMessage) => void): void {
-    this.onNotification = handler;
-  }
-
-  disconnect(): void {
-    for (const [id, req] of this.pending) {
-      clearTimeout(req.timer);
-      req.reject(new Error('Client disconnecting'));
-      this.pending.delete(id);
-    }
-    this.socket?.destroy();
-    this.socket = null;
-    this.decoder.reset();
-  }
-
-  get connected(): boolean {
-    return this.socket !== null && !this.socket.destroyed;
-  }
-
-  private handleMessage(msg: IpcMessage): void {
-    if (msg.type === 'response') {
-      const req = this.pending.get(msg.id);
-      if (!req) return;
-
-      clearTimeout(req.timer);
-      this.pending.delete(msg.id);
-
-      if (msg.error) {
-        req.reject(new Error(msg.error.message));
-      } else {
-        req.resolve(msg.result);
-      }
-    } else if (msg.type === 'notification') {
-      this.onNotification?.(msg);
-    }
-  }
-}

package/src/ipc/protocol.ts

@@ -1,35 +0,0 @@
-import { Buffer } from 'node:buffer';
-import type { IpcMessage } from '../types/ipc.types.js';
-
-export function encodeMessage(msg: IpcMessage): Buffer {
-  const json = JSON.stringify(msg);
-  const payload = Buffer.from(json, 'utf8');
-  const frame = Buffer.alloc(4 + payload.length);
-  frame.writeUInt32BE(payload.length, 0);
-  payload.copy(frame, 4);
-  return frame;
-}
-
-export class MessageDecoder {
-  private buffer = Buffer.alloc(0);
-
-  feed(chunk: Buffer): IpcMessage[] {
-    this.buffer = Buffer.concat([this.buffer, chunk]);
-    const messages: IpcMessage[] = [];
-
-    while (this.buffer.length >= 4) {
-      const length = this.buffer.readUInt32BE(0);
-      if (this.buffer.length < 4 + length) break;
-
-      const json = this.buffer.subarray(4, 4 + length).toString('utf8');
-      this.buffer = this.buffer.subarray(4 + length);
-      messages.push(JSON.parse(json) as IpcMessage);
-    }
-
-    return messages;
-  }
-
-  reset(): void {
-    this.buffer = Buffer.alloc(0);
-  }
-}

package/src/ipc/server.ts

@@ -1,170 +0,0 @@
-import net from 'node:net';
-import fs from 'node:fs';
-import { randomUUID } from 'node:crypto';
-import { getLogger } from '../utils/logger.js';
-import type { IpcMessage } from '../types/ipc.types.js';
-import { encodeMessage, MessageDecoder } from './protocol.js';
-
-export interface IpcRouter {
-  handle(method: string, params: unknown): unknown;
-  listMethods(): string[];
-}
-
-export class IpcServer {
-  private server: net.Server | null = null;
-  private clients = new Map<string, net.Socket>();
-  private logger = getLogger();
-
-  constructor(
-    private router: IpcRouter,
-    private pipeName: string,
-    private daemonName: string = 'brain',
-  ) {}
-
-  start(): void {
-    this.createServer();
-    this.listen();
-  }
-
-  private createServer(): void {
-    this.server = net.createServer((socket) => {
-      const clientId = randomUUID();
-      this.clients.set(clientId, socket);
-      const decoder = new MessageDecoder();
-
-      this.logger.info(`IPC client connected: ${clientId}`);
-
-      socket.on('data', (chunk) => {
-        const messages = decoder.feed(chunk);
-        for (const msg of messages) {
-          this.handleMessage(clientId, msg, socket);
-        }
-      });
-
-      socket.on('close', () => {
-        this.logger.info(`IPC client disconnected: ${clientId}`);
-        this.clients.delete(clientId);
-      });
-
-      socket.on('error', (err) => {
-        this.logger.error(`IPC client ${clientId} error:`, err);
-        this.clients.delete(clientId);
-      });
-    });
-  }
-
-  private listen(retried = false): void {
-    if (!this.server) return;
-
-    this.server.on('error', (err: NodeJS.ErrnoException) => {
-      if (err.code === 'EADDRINUSE' && !retried) {
-        this.logger.warn(`IPC pipe in use, attempting to recover stale pipe: ${this.pipeName}`);
-        this.recoverStalePipe();
-      } else {
-        this.logger.error('IPC server error:', err);
-      }
-    });
-
-    this.server.listen(this.pipeName, () => {
-      this.logger.info(`IPC server listening on ${this.pipeName}`);
-    });
-  }
-
-  private recoverStalePipe(): void {
-    const probe = net.createConnection(this.pipeName);
-
-    probe.on('connect', () => {
-      probe.destroy();
-      this.logger.error(`IPC pipe is held by another running daemon. Stop it first with: ${this.daemonName} stop`);
-    });
-
-    probe.on('error', () => {
-      probe.destroy();
-      this.logger.info('Stale IPC pipe detected, reclaiming...');
-
-      if (process.platform !== 'win32') {
-        try { fs.unlinkSync(this.pipeName); } catch { /* ignore */ }
-      }
-
-      this.createServer();
-      this.server!.on('error', (err) => {
-        this.logger.error('IPC server error after recovery:', err);
-      });
-      this.server!.listen(this.pipeName, () => {
-        this.logger.info(`IPC server recovered and listening on ${this.pipeName}`);
-      });
-    });
-
-    probe.setTimeout(2000, () => {
-      probe.destroy();
-      this.logger.warn('IPC pipe probe timed out, treating as stale');
-      if (process.platform !== 'win32') {
-        try { fs.unlinkSync(this.pipeName); } catch { /* ignore */ }
-      }
-      this.createServer();
-      this.server!.on('error', (err) => {
-        this.logger.error('IPC server error after timeout recovery:', err);
-      });
-      this.server!.listen(this.pipeName, () => {
-        this.logger.info(`IPC server recovered (timeout) and listening on ${this.pipeName}`);
-      });
-    });
-  }
-
-  private handleMessage(_clientId: string, msg: IpcMessage, socket: net.Socket): void {
-    if (msg.type !== 'request' || !msg.method) return;
-
-    try {
-      const result = this.router.handle(msg.method, msg.params);
-      const response: IpcMessage = {
-        id: msg.id,
-        type: 'response',
-        result,
-      };
-      socket.write(encodeMessage(response));
-    } catch (err) {
-      const response: IpcMessage = {
-        id: msg.id,
-        type: 'response',
-        error: { code: -1, message: err instanceof Error ? err.message : String(err) },
-      };
-      socket.write(encodeMessage(response));
-    }
-  }
-
-  notify(clientId: string | null, notification: Omit<IpcMessage, 'id' | 'type'>): void {
-    const msg: IpcMessage = {
-      id: randomUUID(),
-      type: 'notification',
-      ...notification,
-    };
-    const encoded = encodeMessage(msg);
-
-    if (clientId) {
-      const socket = this.clients.get(clientId);
-      if (socket && !socket.destroyed) {
-        socket.write(encoded);
-      }
-    } else {
-      for (const socket of this.clients.values()) {
-        if (!socket.destroyed) {
-          socket.write(encoded);
-        }
-      }
-    }
-  }
-
-  getClientCount(): number {
-    return this.clients.size;
-  }
-
-  stop(): void {
-    for (const socket of this.clients.values()) {
-      socket.destroy();
-    }
-    this.clients.clear();
-    this.server?.close();
-    this.server = null;
-    this.logger.info('IPC server stopped');
-  }
-}