@johpaz/hive 1.1.0

package/packages/core/src/state/store.ts

@@ -0,0 +1,312 @@
+import { logger } from "../utils/logger.ts";
+
+export interface SessionState {
+  id: string;
+  agentId: string;
+  channel: string;
+  userId: string;
+  createdAt: number;
+  lastActivityAt: number;
+  messageCount: number;
+  status: "active" | "idle" | "closed";
+}
+
+export interface AgentState {
+  id: string;
+  name: string;
+  status: "ready" | "busy" | "error";
+  currentSessionId?: string;
+  lastError?: string;
+}
+
+export interface ChannelState {
+  name: string;
+  accountId: string;
+  status: "connected" | "disconnected" | "error";
+  lastActivity?: number;
+  error?: string;
+}
+
+export interface MetricsState {
+  totalMessages: number;
+  totalSessions: number;
+  totalToolCalls: number;
+  averageResponseTime: number;
+  errors: number;
+  startedAt: number;
+}
+
+export interface HiveState {
+  sessions: Map<string, SessionState>;
+  agents: Map<string, AgentState>;
+  channels: Map<string, ChannelState>;
+  metrics: MetricsState;
+}
+
+export interface StateSnapshot {
+  id: string;
+  timestamp: number;
+  state: HiveState;
+  reason?: string;
+  action?: string;
+  correlationId?: string;
+}
+
+interface StateStoreOptions {
+  maxSnapshots?: number;
+  enableSnapshots?: boolean;
+}
+
+const defaultMetrics: MetricsState = {
+  totalMessages: 0,
+  totalSessions: 0,
+  totalToolCalls: 0,
+  averageResponseTime: 0,
+  errors: 0,
+  startedAt: Date.now(),
+};
+
+export class StateStore {
+  private state: HiveState;
+  private snapshots: StateSnapshot[] = [];
+  private readonly maxSnapshots: number;
+  private readonly enableSnapshots: boolean;
+  private listeners: Set<(state: Readonly<HiveState>) => void> = new Set();
+  private correlationId?: string;
+
+  constructor(options: StateStoreOptions = {}) {
+    this.maxSnapshots = options.maxSnapshots ?? 100;
+    this.enableSnapshots = options.enableSnapshots ?? true;
+    this.state = this.createInitialState();
+  }
+
+  setCorrelationId(id: string): void {
+    this.correlationId = id;
+  }
+
+  getCorrelationId(): string | undefined {
+    return this.correlationId;
+  }
+
+  clearCorrelationId(): void {
+    this.correlationId = undefined;
+  }
+
+  private createInitialState(): HiveState {
+    return {
+      sessions: new Map(),
+      agents: new Map(),
+      channels: new Map(),
+      metrics: { ...defaultMetrics },
+    };
+  }
+
+  getState(): Readonly<HiveState> {
+    return this.state;
+  }
+
+  update(updater: (draft: HiveState) => void, reason?: string): void {
+    const newState = this.cloneState(this.state);
+    updater(newState);
+
+    if (this.enableSnapshots) {
+      this.saveSnapshot(newState, reason);
+    }
+
+    this.state = newState;
+    this.notifyListeners();
+  }
+
+  private cloneState(state: HiveState): HiveState {
+    return {
+      sessions: new Map(state.sessions),
+      agents: new Map(state.agents),
+      channels: new Map(state.channels),
+      metrics: { ...state.metrics },
+    };
+  }
+
+  private saveSnapshot(state: HiveState, reason?: string): void {
+    const snapshot: StateSnapshot = {
+      id: crypto.randomUUID(),
+      timestamp: Date.now(),
+      state: this.cloneState(state),
+      reason,
+      action: reason,
+      correlationId: this.correlationId,
+    };
+
+    this.snapshots.push(snapshot);
+
+    if (this.snapshots.length > this.maxSnapshots) {
+      this.snapshots.shift();
+    }
+  }
+
+  getSnapshotAt(timestamp: number): StateSnapshot | undefined {
+    return this.snapshots.find((s) => s.timestamp >= timestamp);
+  }
+
+  getSnapshotById(id: string): StateSnapshot | undefined {
+    return this.snapshots.find((s) => s.id === id);
+  }
+
+  getAllSnapshots(): StateSnapshot[] {
+    return [...this.snapshots];
+  }
+
+  getRecentSnapshots(count: number = 10): StateSnapshot[] {
+    return this.snapshots.slice(-count);
+  }
+
+  subscribe(listener: (state: Readonly<HiveState>) => void): () => void {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+
+  private notifyListeners(): void {
+    const state = this.getState();
+    for (const listener of this.listeners) {
+      try {
+        listener(state);
+      } catch (error) {
+        logger.error("[StateStore] Listener error:", { error: (error as Error).message });
+      }
+    }
+  }
+
+  createSession(session: Omit<SessionState, "createdAt" | "lastActivityAt" | "messageCount" | "status">): SessionState {
+    const newSession: SessionState = {
+      ...session,
+      createdAt: Date.now(),
+      lastActivityAt: Date.now(),
+      messageCount: 0,
+      status: "active",
+    };
+
+    this.update((state) => {
+      state.sessions.set(session.id, newSession);
+      state.metrics.totalSessions++;
+    }, `Session created: ${session.id}`);
+
+    return newSession;
+  }
+
+  updateSession(sessionId: string, updates: Partial<SessionState>): void {
+    this.update((state) => {
+      const session = state.sessions.get(sessionId);
+      if (session) {
+        state.sessions.set(sessionId, { ...session, ...updates });
+      }
+    }, `Session updated: ${sessionId}`);
+  }
+
+  closeSession(sessionId: string): void {
+    this.update((state) => {
+      const session = state.sessions.get(sessionId);
+      if (session) {
+        state.sessions.set(sessionId, { ...session, status: "closed" });
+      }
+    }, `Session closed: ${sessionId}`);
+  }
+
+  incrementMessageCount(sessionId: string): void {
+    this.update((state) => {
+      const session = state.sessions.get(sessionId);
+      if (session) {
+        session.messageCount++;
+        session.lastActivityAt = Date.now();
+        state.sessions.set(sessionId, session);
+        state.metrics.totalMessages++;
+      }
+    });
+  }
+
+  registerAgent(agent: Omit<AgentState, "status">): void {
+    this.update((state) => {
+      state.agents.set(agent.id, { ...agent, status: "ready" });
+    }, `Agent registered: ${agent.id}`);
+  }
+
+  updateAgent(agentId: string, updates: Partial<AgentState>): void {
+    this.update((state) => {
+      const agent = state.agents.get(agentId);
+      if (agent) {
+        state.agents.set(agentId, { ...agent, ...updates });
+      }
+    }, `Agent updated: ${agentId}`);
+  }
+
+  updateChannel(channelName: string, accountId: string, updates: Partial<ChannelState>): void {
+    this.update((state) => {
+      const key = `${channelName}:${accountId}`;
+      const channel = state.channels.get(key);
+      if (channel) {
+        state.channels.set(key, { ...channel, ...updates });
+      } else {
+        state.channels.set(key, {
+          name: channelName,
+          accountId,
+          status: "disconnected",
+          ...updates,
+        });
+      }
+    }, `Channel updated: ${channelName}:${accountId}`);
+  }
+
+  recordToolCall(duration: number, success: boolean): void {
+    this.update((state) => {
+      state.metrics.totalToolCalls++;
+      if (!success) {
+        state.metrics.errors++;
+      }
+      const total = state.metrics.totalToolCalls;
+      const prevAvg = state.metrics.averageResponseTime;
+      state.metrics.averageResponseTime = prevAvg + (duration - prevAvg) / total;
+    });
+  }
+
+  reset(): void {
+    this.state = this.createInitialState();
+    this.snapshots = [];
+    this.saveSnapshot(this.state, "Store reset");
+  }
+
+  exportState(): string {
+    const exportable = {
+      sessions: Object.fromEntries(this.state.sessions),
+      agents: Object.fromEntries(this.state.agents),
+      channels: Object.fromEntries(this.state.channels),
+      metrics: this.state.metrics,
+    };
+    return JSON.stringify(exportable, null, 2);
+  }
+
+  export(): string {
+    return this.exportState();
+  }
+
+  getStats(): {
+    sessionsCount: number;
+    activeSessions: number;
+    agentsCount: number;
+    channelsCount: number;
+    snapshotsCount: number;
+    uptime: number;
+  } {
+    const activeSessions = Array.from(this.state.sessions.values()).filter(
+      (s) => s.status === "active"
+    ).length;
+
+    return {
+      sessionsCount: this.state.sessions.size,
+      activeSessions,
+      agentsCount: this.state.agents.size,
+      channelsCount: this.state.channels.size,
+      snapshotsCount: this.snapshots.length,
+      uptime: Date.now() - this.state.metrics.startedAt,
+    };
+  }
+}
+
+export const stateStore = new StateStore();

package/packages/core/src/storage/bun-sqlite-store.ts

@@ -0,0 +1,188 @@
+import { Database } from "bun:sqlite"
+
+export interface StoreValue {
+  [key: string]: unknown
+}
+
+interface StoreRecord {
+  namespace: string
+  key: string
+  value: string
+}
+
+export class BunSqliteStore {
+  private db: Database
+  private cache: Map<string, StoreValue> = new Map()
+
+  constructor(db: Database) {
+    this.db = db
+    this.initTable()
+  }
+
+  private initTable() {
+    this.db.query(`
+      CREATE TABLE IF NOT EXISTS lg_store (
+        namespace TEXT NOT NULL,
+        key TEXT NOT NULL,
+        value TEXT NOT NULL,
+        PRIMARY KEY (namespace, key)
+      )
+    `).run()
+  }
+
+  async get(key: string): Promise<StoreValue | undefined> {
+    const cacheKey = `global:${key}`
+    if (this.cache.has(cacheKey)) {
+      return this.cache.get(cacheKey)
+    }
+
+    const row = this.db
+      .query<StoreRecord, [string]>(
+        "SELECT * FROM lg_store WHERE namespace = 'global' AND key = ?"
+      )
+      .get(key)
+
+    if (!row) return undefined
+
+    try {
+      const parsed = JSON.parse(row.value) as StoreValue
+      this.cache.set(cacheKey, parsed)
+      return parsed
+    } catch {
+      const fallback = { value: row.value }
+      this.cache.set(cacheKey, fallback)
+      return fallback
+    }
+  }
+
+  async set(key: string, value: StoreValue): Promise<void> {
+    const serialized = JSON.stringify(value)
+    this.db
+      .query(
+        "INSERT OR REPLACE INTO lg_store (namespace, key, value) VALUES (?, ?, ?)"
+      )
+      .run("global", key, serialized)
+    this.cache.set(`global:${key}`, value)
+  }
+
+  async delete(key: string): Promise<void> {
+    this.db
+      .query("DELETE FROM lg_store WHERE namespace = 'global' AND key = ?")
+      .run(key)
+    this.cache.delete(`global:${key}`)
+  }
+
+  async *list(prefix?: string): AsyncGenerator<[string, StoreValue]> {
+    let query = "SELECT * FROM lg_store WHERE namespace = 'global'"
+    const params: string[] = []
+
+    if (prefix) {
+      query += " AND key LIKE ?"
+      params.push(`${prefix}%`)
+    }
+
+    const rows = this.db.query<StoreRecord, string[]>(query).all(...params)
+
+    for (const row of rows) {
+      try {
+        const value = JSON.parse(row.value) as StoreValue
+        yield [row.key, value]
+      } catch {
+        yield [row.key, { value: row.value }]
+      }
+    }
+  }
+
+  async getByNamespace(namespace: string, key: string): Promise<StoreValue | undefined> {
+    const cacheKey = `${namespace}:${key}`
+    if (this.cache.has(cacheKey)) {
+      return this.cache.get(cacheKey)
+    }
+
+    const row = this.db
+      .query<StoreRecord, [string, string]>(
+        "SELECT * FROM lg_store WHERE namespace = ? AND key = ?"
+      )
+      .get(namespace, key)
+
+    if (!row) return undefined
+
+    try {
+      const parsed = JSON.parse(row.value) as StoreValue
+      this.cache.set(cacheKey, parsed)
+      return parsed
+    } catch {
+      const fallback = { value: row.value }
+      this.cache.set(cacheKey, fallback)
+      return fallback
+    }
+  }
+
+  async setByNamespace(namespace: string, key: string, value: StoreValue): Promise<void> {
+    const serialized = JSON.stringify(value)
+    this.db
+      .query(
+        "INSERT OR REPLACE INTO lg_store (namespace, key, value) VALUES (?, ?, ?)"
+      )
+      .run(namespace, key, serialized)
+    this.cache.set(`${namespace}:${key}`, value)
+  }
+}
+
+let storeInstance: BunSqliteStore | null = null
+
+export function getGlobalStore(db: Database): BunSqliteStore {
+  if (!storeInstance) {
+    storeInstance = new BunSqliteStore(db)
+  }
+  return storeInstance
+}
+
+export function invalidateStore(): void {
+  storeInstance = null
+}
+
+export async function loadContextToStore(db: Database): Promise<void> {
+  const store = getGlobalStore(db)
+
+  const tools = db.query<any, []>("SELECT * FROM tools WHERE enabled = 1").all()
+  await store.set("tools:active", {
+    tools: tools.map((t: any) => ({
+      id: t.id,
+      name: t.name,
+      description: t.description,
+      category: t.category,
+      schema: t.schema ? JSON.parse(t.schema) : null,
+    }))
+  })
+
+  const skills = db.query<any, []>("SELECT * FROM skills WHERE enabled = 1").all()
+  await store.set("skills:active", {
+    skills: skills.map((s: any) => ({
+      id: s.id,
+      name: s.name,
+      description: s.description,
+    }))
+  })
+
+  const mcpServers = db.query<any, []>("SELECT * FROM mcp_servers WHERE enabled = 1 AND status = 'connected'").all()
+  await store.set("mcp:connected", {
+    servers: mcpServers.map((m: any) => ({
+      id: m.id,
+      name: m.name,
+      transport: m.transport,
+      command: m.command,
+      args: m.args,
+      url: m.url,
+    }))
+  })
+
+  const ethics = db.query<any, []>("SELECT * FROM ethics WHERE enabled = 1").all()
+  await store.set("ethics:rules", {
+    rules: ethics.map((e: any) => ({
+      id: e.id,
+      name: e.name,
+      content: e.content,
+    }))
+  })
+}

package/packages/core/src/storage/crypto.ts

@@ -0,0 +1,101 @@
+import { randomBytes, createCipheriv, createDecipheriv, createHash } from "node:crypto";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import * as path from "node:path";
+import { homedir } from "node:os";
+
+let _encryptionKey: Buffer | null = null;
+
+function getEncryptionKey(): Buffer {
+  if (_encryptionKey) return _encryptionKey;
+
+  const masterKey = process.env.HIVE_MASTER_KEY;
+
+  if (masterKey) {
+    _encryptionKey = Buffer.from(masterKey.slice(0, 32).padEnd(32, "0"), "utf8");
+  } else {
+    const hiveDir = process.env.HIVE_HOME || path.join(homedir(), ".hive");
+    if (!existsSync(hiveDir)) {
+      mkdirSync(hiveDir, { recursive: true });
+    }
+    const keyPath = path.join(hiveDir, ".master.key");
+
+    if (existsSync(keyPath)) {
+      const storedKey = readFileSync(keyPath, "utf-8").trim();
+      _encryptionKey = Buffer.from(storedKey, "hex");
+    } else {
+      _encryptionKey = randomBytes(32);
+      writeFileSync(keyPath, _encryptionKey.toString("hex"), { mode: 0o600 });
+    }
+  }
+
+  return _encryptionKey;
+}
+
+export interface EncryptedData {
+  encrypted: string;
+  iv: string;
+}
+
+export function encrypt(text: string): EncryptedData {
+  const key = getEncryptionKey();
+  const iv = randomBytes(16);
+
+  const cipher = createCipheriv("aes-256-gcm", key, iv);
+
+  let encrypted = cipher.update(text, "utf8", "hex");
+  encrypted += cipher.final("hex");
+  const authTag = cipher.getAuthTag().toString("hex");
+
+  return {
+    encrypted: encrypted + ":" + authTag,
+    iv: iv.toString("hex"),
+  };
+}
+
+export function decrypt(data: EncryptedData): string {
+  const key = getEncryptionKey();
+  const iv = Buffer.from(data.iv, "hex");
+  const [encrypted, authTag] = data.encrypted.split(":");
+
+  const decipher = createDecipheriv("aes-256-gcm", key, iv);
+  decipher.setAuthTag(Buffer.from(authTag, "hex"));
+
+  let decrypted = decipher.update(encrypted, "hex", "utf8");
+  decrypted += decipher.final("utf8");
+
+  return decrypted;
+}
+
+export function encryptApiKey(apiKey: string): { encrypted: string; iv: string } {
+  return encrypt(apiKey);
+}
+
+export function decryptApiKey(encrypted: string, iv: string): string {
+  return decrypt({ encrypted, iv });
+}
+
+export function encryptConfig(config: Record<string, unknown>): { encrypted: string; iv: string } {
+  return encrypt(JSON.stringify(config));
+}
+
+export function decryptConfig(encrypted: string, iv: string): Record<string, unknown> {
+  const decrypted = decrypt({ encrypted, iv });
+  return JSON.parse(decrypted);
+}
+
+export function hashPassword(password: string): string {
+  const hasher = new Bun.CryptoHasher("sha256");
+  hasher.update(password);
+  return hasher.digest("hex");
+}
+
+export function verifyPassword(password: string, hash: string): boolean {
+  const hasher = new Bun.CryptoHasher("sha256");
+  hasher.update(password);
+  return hasher.digest("hex") === hash;
+}
+
+export function maskApiKey(apiKey: string): string {
+  if (!apiKey || apiKey.length < 8) return "••••••••";
+  return apiKey.slice(0, 4) + "••••••••" + apiKey.slice(-4);
+}