@johpaz/hive 1.1.0

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

@@ -0,0 +1,95 @@
+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

@@ -0,0 +1,192 @@
+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;
+  content?: string;
+  chunk?: string;
+  audio?: string;
+  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

@@ -0,0 +1,157 @@
+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/index.ts

@@ -0,0 +1,19 @@
+export * from "./gateway/index.ts";
+export * from "./gateway/server.ts";
+export * from "./agent/index.ts";
+export * from "./agent/context.ts";
+export * from "./channels/index.ts";
+export * from "./channels/manager.ts";
+export * from "./config/index.ts";
+export * from "./utils/logger.ts";
+export * from "./utils/crypto.ts";
+export * from "./utils/retry.ts";
+export * from "./security/index.ts";
+export * from "./heartbeat/index.ts";
+export * from "./memory/notes.ts";
+export * from "./events/event-bus.ts";
+export * from "./state/store.ts";
+export * from "./resilience/circuit-breaker.ts";
+export * from "./plugins/index.ts";
+export * from "./canvas/index.ts";
+export type { Tool, ToolResult } from "./agent/native-tools.ts";