@johpaz/hive 1.7.2 → 1.7.3

package/packages/core/src/gateway/session.ts

@@ -1,95 +0,0 @@
-import type { ServerWebSocket } from "bun";
-
-export interface SessionId {
-  userId: string;
-}
-
-export function parseSessionId(sessionId: string): SessionId | null {
-  if (!sessionId || sessionId.trim() === "") {
-    return null;
-  }
-  return { userId: sessionId };
-}
-
-export function formatSessionId(session: SessionId): string {
-  return session.userId;
-}
-
-export interface Session {
-  id: string;
-  parsed: SessionId;
-  createdAt: Date;
-  lastActivityAt: Date;
-  messageCount: number;
-  ws?: ServerWebSocket<unknown>;
-}
-
-export class SessionManager {
-  private sessions: Map<string, Session> = new Map();
-
-  create(sessionId: string, ws?: ServerWebSocket<unknown>): Session {
-    const parsed = parseSessionId(sessionId);
-    if (!parsed) {
-      throw new Error(`Invalid session ID: ${sessionId}`);
-    }
-
-    const existing = this.sessions.get(sessionId);
-    if (existing) {
-      existing.lastActivityAt = new Date();
-      if (ws) {
-        existing.ws = ws;
-      }
-      return existing;
-    }
-
-    const session: Session = {
-      id: sessionId,
-      parsed,
-      createdAt: new Date(),
-      lastActivityAt: new Date(),
-      messageCount: 0,
-    };
-    if (ws !== undefined) {
-      session.ws = ws;
-    }
-
-    this.sessions.set(sessionId, session);
-    return session;
-  }
-
-  get(sessionId: string): Session | undefined {
-    return this.sessions.get(sessionId);
-  }
-
-  touch(sessionId: string): void {
-    const session = this.sessions.get(sessionId);
-    if (session) {
-      session.lastActivityAt = new Date();
-      session.messageCount++;
-    }
-  }
-
-  delete(sessionId: string): boolean {
-    return this.sessions.delete(sessionId);
-  }
-
-  list(): Session[] {
-    return Array.from(this.sessions.values());
-  }
-
-  prune(maxAgeMs: number): number {
-    const now = Date.now();
-    let pruned = 0;
-
-    for (const [id, session] of this.sessions) {
-      if (now - session.lastActivityAt.getTime() > maxAgeMs) {
-        this.sessions.delete(id);
-        pruned++;
-      }
-    }
-
-    return pruned;
-  }
-}
-
-export const sessionManager = new SessionManager();

package/packages/core/src/gateway/slash-commands.ts

@@ -1,193 +0,0 @@
-import type { ServerWebSocket } from "bun";
-import { sessionManager } from "./session.ts";
-import { laneQueue } from "./lane-queue.ts";
-import { logger } from "../utils/logger.ts";
-
-export interface InboundMessage {
-  type: "message" | "command" | "ping" | "join" | "canvas_subscribe" | "canvas_unsubscribe" | "logs_subscribe" | "logs_unsubscribe" | "audio";
-  sessionId: string;
-  content?: string;
-  audio?: string;
-  command?: string;
-  args?: string[];
-  metadata?: Record<string, unknown>;
-}
-
-export interface OutboundMessage {
-  type: "message" | "stream" | "status" | "error" | "pong" | "command_result" | "joined" | "typing" | "audio" | "welcome";
-  sessionId: string;
-  id?: string; // Message ID for streaming
-  content?: string;
-  chunk?: string;
-  isChunk?: boolean; // True if this is a streaming chunk
-  isLast?: boolean;
-  isTyping?: boolean;
-  isStep?: boolean;
-  stepType?: "plan" | "tool_call" | "tool_result" | "text";
-  status?: {
-    state: string;
-    model?: string;
-    tokens?: number;
-  };
-  error?: string;
-  result?: unknown;
-  // Welcome message fields
-  user?: {
-    id: string;
-    name: string;
-    language: string;
-  } | null;
-  agent?: {
-    id: string;
-    name: string;
-    provider: string;
-    model: string;
-  } | null;
-  channels?: string[];
-  voice?: {
-    enabled: boolean;
-    sttProvider: string | null;
-    ttsProvider: string | null;
-  };
-  codeBridge?: string[];
-}
-
-export interface SlashCommand {
-  name: string;
-  description: string;
-  handler: (sessionId: string, args: string[], ws: ServerWebSocket<unknown>) => Promise<unknown>;
-}
-
-const slashCommands = new Map<string, SlashCommand>();
-
-export function registerSlashCommand(command: SlashCommand): void {
-  slashCommands.set(command.name, command);
-}
-
-export function isSlashCommand(content: string): boolean {
-  return content.startsWith("/") && content.length > 1;
-}
-
-export function parseSlashCommand(content: string): { name: string; args: string[] } | null {
-  if (!isSlashCommand(content)) return null;
-
-  const parts = content.slice(1).split(/\s+/);
-  const name = parts[0]?.toLowerCase();
-  if (!name) return null;
-
-  return {
-    name,
-    args: parts.slice(1),
-  };
-}
-
-export async function executeSlashCommand(
-  sessionId: string,
-  content: string,
-  ws: ServerWebSocket<unknown>
-): Promise<OutboundMessage | null> {
-  const parsed = parseSlashCommand(content);
-  if (!parsed) {
-    return null;
-  }
-
-  const command = slashCommands.get(parsed.name);
-  if (!command) {
-    return null;
-  }
-
-  logger.info(`Executing slash command: /${parsed.name}`, { sessionId, args: parsed.args });
-
-  try {
-    const result = await command.handler(sessionId, parsed.args, ws);
-    return {
-      type: "command_result",
-      sessionId,
-      result,
-    };
-  } catch (error) {
-    logger.error(`Slash command failed: /${parsed.name}`, { error: (error as Error).message });
-    return {
-      type: "error",
-      sessionId,
-      error: (error as Error).message,
-    };
-  }
-}
-
-registerSlashCommand({
-  name: "stop",
-  description: "Stop the current task",
-  handler: async (sessionId) => {
-    const cancelled = laneQueue.cancel(sessionId);
-    return {
-      success: cancelled,
-      message: cancelled ? "Task stopped" : "No task running",
-    };
-  },
-});
-
-registerSlashCommand({
-  name: "status",
-  description: "Show session status",
-  handler: async (sessionId) => {
-    const session = sessionManager.get(sessionId);
-    const queueStatus = laneQueue.getStatus(sessionId);
-
-    return {
-      sessionId,
-      createdAt: session?.createdAt,
-      messageCount: session?.messageCount,
-      queueLength: queueStatus.queueLength,
-      isProcessing: queueStatus.running !== undefined,
-    };
-  },
-});
-
-registerSlashCommand({
-  name: "new",
-  description: "Start a new session",
-  handler: async (sessionId) => {
-    sessionManager.delete(sessionId);
-    return { success: true, message: "Session reset" };
-  },
-});
-
-registerSlashCommand({
-  name: "compact",
-  description: "Force context compaction",
-  handler: async (sessionId) => {
-    logger.info(`Compaction requested for session: ${sessionId}`);
-    return { success: true, message: "Compaction triggered" };
-  },
-});
-
-registerSlashCommand({
-  name: "reset",
-  description: "Reset the current context",
-  handler: async (sessionId) => {
-    logger.info(`Context reset requested for session: ${sessionId}`);
-    return { success: true, message: "Context reset" };
-  },
-});
-
-registerSlashCommand({
-  name: "model",
-  description: "Switch model for this session",
-  handler: async (_sessionId, args) => {
-    const modelName = args[0];
-    if (!modelName) {
-      return { success: false, message: "Usage: /model <model-name>" };
-    }
-    return { success: true, message: `Model switched to: ${modelName}` };
-  },
-});
-
-registerSlashCommand({
-  name: "help",
-  description: "Show available commands",
-  handler: async () => {
-    const commands = Array.from(slashCommands.values()).map((c) => `/${c.name} - ${c.description}`);
-    return { commands };
-  },
-});

package/packages/core/src/heartbeat/index.ts

@@ -1,157 +0,0 @@
-import type { Config } from "../config/loader.ts";
-import { logger } from "../utils/logger.ts";
-
-export interface HealthStatus {
-  status: "healthy" | "degraded" | "unhealthy";
-  checks: Record<string, {
-    status: "ok" | "warning" | "error";
-    message?: string;
-    latency?: number;
-  }>;
-  uptime: number;
-  lastCheck: Date;
-}
-
-export interface HeartbeatOptions {
-  intervalMs?: number;
-  onHealthChange?: (status: HealthStatus) => void;
-}
-
-type HealthCheck = () => Promise<{
-  status: "ok" | "warning" | "error";
-  message?: string;
-  latency?: number;
-}>;
-
-export class Heartbeat {
-  private intervalMs: number;
-  private checks: Map<string, HealthCheck> = new Map();
-  private intervalId: Timer | null = null;
-  private startTime: Date;
-  private lastStatus: HealthStatus | null = null;
-  private onHealthChange?: (status: HealthStatus) => void;
-  private log = logger.child("heartbeat");
-
-  constructor(_config: Config, options: HeartbeatOptions = {}) {
-    this.intervalMs = options.intervalMs ?? 30000;
-    this.onHealthChange = options.onHealthChange;
-    this.startTime = new Date();
-  }
-
-  registerCheck(name: string, check: HealthCheck): void {
-    this.checks.set(name, check);
-    this.log.debug(`Registered health check: ${name}`);
-  }
-
-  removeCheck(name: string): boolean {
-    return this.checks.delete(name);
-  }
-
-  async runChecks(): Promise<HealthStatus> {
-    const checks: HealthStatus["checks"] = {};
-    let overallStatus: "healthy" | "degraded" | "unhealthy" = "healthy";
-
-    for (const [name, check] of this.checks) {
-      try {
-        const start = Date.now();
-        const result = await check();
-        const latency = Date.now() - start;
-
-        checks[name] = {
-          status: result.status,
-          message: result.message,
-          latency: result.latency ?? latency,
-        };
-
-        if (result.status === "warning" && overallStatus === "healthy") {
-          overallStatus = "degraded";
-        } else if (result.status === "error") {
-          overallStatus = "unhealthy";
-        }
-      } catch (error) {
-        checks[name] = {
-          status: "error",
-          message: (error as Error).message,
-        };
-        overallStatus = "unhealthy";
-      }
-    }
-
-    const status: HealthStatus = {
-      status: overallStatus,
-      checks,
-      uptime: Date.now() - this.startTime.getTime(),
-      lastCheck: new Date(),
-    };
-
-    const prevStatus = this.lastStatus?.status;
-    if (prevStatus && prevStatus !== overallStatus) {
-      this.log.info(`Health status changed: ${prevStatus} -> ${overallStatus}`);
-      this.onHealthChange?.(status);
-    }
-
-    this.lastStatus = status;
-    return status;
-  }
-
-  start(): void {
-    if (this.intervalId) {
-      this.log.warn("Heartbeat already running");
-      return;
-    }
-
-    this.runChecks();
-
-    this.intervalId = setInterval(async () => {
-      await this.runChecks();
-    }, this.intervalMs);
-
-    this.log.info(`Heartbeat started (interval: ${this.intervalMs}ms)`);
-  }
-
-  stop(): void {
-    if (this.intervalId) {
-      clearInterval(this.intervalId);
-      this.intervalId = null;
-      this.log.info("Heartbeat stopped");
-    }
-  }
-
-  getStatus(): HealthStatus | null {
-    return this.lastStatus;
-  }
-
-  isRunning(): boolean {
-    return this.intervalId !== null;
-  }
-}
-
-export function createHeartbeat(config: Config, options?: HeartbeatOptions): Heartbeat {
-  const heartbeat = new Heartbeat(config, options);
-
-  heartbeat.registerCheck("memory", async () => {
-    const memUsage = process.memoryUsage();
-    const heapUsedMB = Math.round(memUsage.heapUsed / 1024 / 1024);
-    const heapTotalMB = Math.round(memUsage.heapTotal / 1024 / 1024);
-    const ratio = memUsage.heapUsed / memUsage.heapTotal;
-
-    if (ratio > 0.9) {
-      return {
-        status: "error",
-        message: `Memory critically high: ${heapUsedMB}/${heapTotalMB}MB`,
-      };
-    } else if (ratio > 0.75) {
-      return {
-        status: "warning",
-        message: `Memory usage high: ${heapUsedMB}/${heapTotalMB}MB`,
-      };
-    }
-
-    return {
-      status: "ok",
-      message: `${heapUsedMB}/${heapTotalMB}MB used`,
-    };
-  });
-
-  return heartbeat;
-}

package/packages/core/src/mcp/hot-reload.ts

@@ -1,213 +0,0 @@
-/**
- * MCP Hot Reload
- * 
- * Watches for MCP server changes in DB and updates MCP Manager automatically
- */
-
-import { getDb } from "../storage/sqlite";
-import { logger } from "../utils/logger";
-import type { MCPClientManager } from "@johpaz/hive-mcp";
-import { decryptConfig } from "../storage/crypto";
-import { syncMCPToolsToFTS, removeMCPToolsFromFTS } from "../agent/tool-selector";
-
-const log = logger.child("mcp:hot-reload");
-
-let _watchInterval: Timer | null = null;
-let _lastKnownServers = new Set<string>();
-
-/**
- * Sync MCP tools to database (tools_mcp table + FTS5)
- */
-async function syncMCPToolsToDB(
-  serverId: string,
-  serverName: string,
-  tools: Array<{ name: string; description: string; inputSchema?: any }>
-): Promise<void> {
-  const db = getDb();
-  
-  try {
-    const syncTransaction = db.transaction(() => {
-      // Remove existing tools from this server
-      db.query("DELETE FROM tools_mcp WHERE server_id = ?").run(serverId);
-      
-      // Insert new tools
-      const insert = db.prepare(`
-        INSERT INTO tools_mcp(id, server_id, server_name, name, description, input_schema, enabled, active, updated_at)
-        VALUES (?, ?, ?, ?, ?, ?, 1, 0, unixepoch())
-      `);
-      
-      for (const tool of tools) {
-        const toolId = `mcp_${serverId}_${tool.name.toLowerCase().replace(/[^a-z0-9]/g, '_')}`;
-        const inputSchemaJson = tool.inputSchema ? JSON.stringify(tool.inputSchema) : null;
-        
-        insert.run(toolId, serverId, serverName, tool.name, tool.description, inputSchemaJson);
-      }
-    });
-    
-    syncTransaction();
-    log.info(`[hot-reload] Synced ${tools.length} MCP tools to DB for ${serverName}`);
-  } catch (err) {
-    log.error(`[hot-reload] Failed to sync MCP tools to DB: ${(err as Error).message}`);
-    throw err;
-  }
-}
-
-/**
- * Remove MCP tools from database
- */
-async function removeMCPToolsFromDB(serverId: string): Promise<void> {
-  const db = getDb();
-  
-  try {
-    db.query("DELETE FROM tools_mcp WHERE server_id = ?").run(serverId);
-    log.info(`[hot-reload] Removed MCP tools for server ${serverId} from DB`);
-  } catch (err) {
-    log.error(`[hot-reload] Failed to remove MCP tools from DB: ${(err as Error).message}`);
-    throw err;
-  }
-}
-
-/**
- * Set MCP tools active/inactive based on server connection status
- */
-async function setMCPToolsActive(serverId: string, active: boolean): Promise<void> {
-  const db = getDb();
-  
-  try {
-    db.query("UPDATE tools_mcp SET active = ?, updated_at = unixepoch() WHERE server_id = ?").run(active ? 1 : 0, serverId);
-    log.info(`[hot-reload] Set MCP tools ${active ? 'active' : 'inactive'} for server ${serverId}`);
-  } catch (err) {
-    log.error(`[hot-reload] Failed to set MCP tools active: ${(err as Error).message}`);
-    throw err;
-  }
-}
-
-/**
- * Start watching for MCP server changes
- * Checks every 2 seconds for new/removed servers
- */
-export function startMCPHotReload(mcpManager: MCPClientManager): void {
-  if (_watchInterval) {
-    log.warn("MCP Hot Reload already running");
-    return;
-  }
-
-  log.info("Starting MCP Hot Reload watcher (2s interval)");
-
-  // Initial sync - sync all currently connected servers
-  syncMCPServers(mcpManager).then(() => {
-    log.info("Initial MCP server sync complete");
-  }).catch(err => {
-    log.error(`Initial MCP server sync failed: ${err.message}`);
-  });
-
-  // Watch for changes
-  _watchInterval = setInterval(() => {
-    syncMCPServers(mcpManager);
-  }, 2000);
-}
-
-/**
- * Stop watching
- */
-export function stopMCPHotReload(): void {
-  if (_watchInterval) {
-    clearInterval(_watchInterval);
-    _watchInterval = null;
-    log.info("MCP Hot Reload stopped");
-  }
-}
-
-/**
- * Sync MCP servers from DB to MCP Manager
- */
-async function syncMCPServers(mcpManager: MCPClientManager): Promise<void> {
-  try {
-    const db = getDb();
-    const dbServers = db.query(`SELECT * FROM mcp_servers WHERE enabled = 1`).all() as Record<string, any>[];
-    
-    const currentServerNames = new Set(dbServers.map(s => s.id || s.name));
-    
-    // Detect new servers
-    for (const server of dbServers) {
-      const serverName = server.id || server.name;
-      
-      if (!_lastKnownServers.has(serverName)) {
-        log.info(`New MCP server detected: ${serverName} - connecting...`);
-        
-        try {
-          const mcpServerConfig: any = {
-            transport: server.transport,
-            command: server.command,
-            args: server.args ? JSON.parse(server.args) : [],
-            url: server.url,
-            enabled: true,
-          };
-          
-          if (server.headers_encrypted && server.headers_iv) {
-            mcpServerConfig.headers = decryptConfig(server.headers_encrypted, server.headers_iv);
-          }
-          
-          // Update MCP Manager config (auto-connects new servers)
-          const currentConfig = (mcpManager as any).config || { servers: {} };
-          await mcpManager.updateConfig({
-            ...currentConfig,
-            servers: {
-              ...currentConfig.servers,
-              [serverName]: mcpServerConfig,
-            },
-          });
-          
-          // Wait a bit for connection to establish
-          await new Promise(resolve => setTimeout(resolve, 500));
-          
-          // Get tools and update DB status
-          const tools = mcpManager.getServerTools(serverName) || [];
-          db.query(`UPDATE mcp_servers SET status = ?, tools_count = ? WHERE id = ?`).run("connected", tools.length, serverName);
-          
-          // Sync MCP tools to database (tools_mcp + FTS5 via triggers)
-          if (tools.length > 0) {
-            await syncMCPToolsToDB(serverName, serverName, tools);
-            await setMCPToolsActive(serverName, true);
-          }
-          
-          log.info(`✅ MCP server ${serverName} connected with ${tools.length} tools`);
-        } catch (error) {
-          log.error(`Failed to connect new MCP server ${serverName}: ${(error as Error).message}`);
-          db.query(`UPDATE mcp_servers SET status = ? WHERE id = ?`).run("error", serverName);
-        }
-      }
-    }
-    
-    // Detect removed servers
-    for (const oldName of _lastKnownServers) {
-      if (!currentServerNames.has(oldName)) {
-        log.info(`MCP server removed: ${oldName} - disconnecting...`);
-        
-        try {
-          await mcpManager.disconnectServer(oldName);
-          db.query(`UPDATE mcp_servers SET status = ? WHERE id = ?`).run("disconnected", oldName);
-          
-          // Remove MCP tools from database (triggers will remove from FTS5)
-          await removeMCPToolsFromDB(oldName);
-          
-          log.info(`✅ MCP server ${oldName} disconnected`);
-        } catch (error) {
-          log.error(`Failed to disconnect MCP server ${oldName}: ${(error as Error).message}`);
-        }
-      }
-    }
-    
-    _lastKnownServers = currentServerNames;
-    
-  } catch (error) {
-    log.error(`MCP Hot Reload sync failed: ${(error as Error).message}`);
-  }
-}
-
-/**
- * Get current watched server count
- */
-export function getWatchedServerCount(): number {
-  return _lastKnownServers.size;
-}

package/packages/core/src/mcp/singleton.ts

@@ -1,21 +0,0 @@
-/**
- * MCP Manager Singleton
- * 
- * Provides global access to the MCP Manager instance
- */
-
-import type { MCPClientManager } from "@johpaz/hive-mcp";
-
-let _mcpManager: MCPClientManager | null = null;
-
-export function setMCPManager(m: MCPClientManager): void {
-  _mcpManager = m;
-}
-
-export function getMCPManager(): MCPClientManager | null {
-  return _mcpManager;
-}
-
-export function hasMCPManager(): boolean {
-  return _mcpManager !== null;
-}

package/packages/core/src/memory/index.ts

@@ -1 +0,0 @@
-export * from "./notes.ts";