@johpaz/hive 1.1.0

package/packages/core/src/config/loader.ts

@@ -0,0 +1,529 @@
+import * as z from "zod";
+import { mkdirSync, existsSync, readFileSync } from "node:fs";
+import * as path from "node:path";
+
+const LogLevelSchema = z.enum(["debug", "info", "warn", "error"]);
+const DMPolicySchema = z.enum(["open", "pairing", "allowlist"]);
+const TransportSchema = z.enum(["stdio", "sse", "websocket"]);
+
+export function loadEnv(hiveDir: string): void {
+  const envPath = path.join(hiveDir, ".env");
+  if (existsSync(envPath)) {
+    try {
+      const text = readFileSync(envPath, "utf8");
+      const lines = text.split("\n");
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#")) continue;
+
+        const [key, ...valueParts] = trimmed.split("=");
+        if (key && valueParts.length > 0) {
+          const value = valueParts.join("=").trim().replace(/^['"]|['"]$/g, "");
+          process.env[key.trim()] = value;
+        }
+      }
+    } catch (e) {
+      // Ignore errors loading .env
+    }
+  }
+}
+
+export function getHiveDir(): string {
+  // Priority 1: HIVE_HOME explicitly set
+  if (process.env.HIVE_HOME) {
+    const hiveDir = process.env.HIVE_HOME.startsWith("~")
+      ? path.join(process.env.HOME || "", process.env.HIVE_HOME.slice(1))
+      : process.env.HIVE_HOME;
+    loadEnv(hiveDir);
+    return hiveDir;
+  }
+
+  // Priority 2: HIVE_DEV mode defaults (Local folder)
+  if (process.env.HIVE_DEV === "1" || process.env.HIVE_DEV === "true") {
+    const localDir = path.join(process.cwd(), ".hive-dev");
+    loadEnv(localDir);
+    return localDir;
+  }
+
+  // Priority 3: Default ~/.hive
+  const defaultDir = path.join(process.env.HOME || "", ".hive");
+  loadEnv(defaultDir);
+  return defaultDir;
+}
+
+const expandPath = (p: string): string => {
+  if (p.startsWith("~/.hive")) {
+    const hiveDir = getHiveDir();
+    return p.replace("~/.hive", hiveDir);
+  }
+  if (p.startsWith("~")) {
+    return path.join(process.env.HOME || "", p.slice(1));
+  }
+  return p;
+};
+
+const expandEnvVars = (value: string): string => {
+  return value.replace(/\$\{([^}]+)\}/g, (_, key) => {
+    return process.env[key] || "";
+  });
+};
+
+const expandEnvInObject = <T>(obj: T): T => {
+  if (typeof obj === "string") {
+    return expandEnvVars(obj) as T;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map(expandEnvInObject) as T;
+  }
+  if (obj !== null && typeof obj === "object") {
+    const result: Record<string, unknown> = {};
+    for (const [key, value] of Object.entries(obj)) {
+      result[key] = expandEnvInObject(value);
+    }
+    return result as T;
+  }
+  return obj;
+};
+
+const ProviderConfigSchema = z.object({
+  apiKey: z.string().optional(),
+  baseUrl: z.string().optional(),
+  rateLimit: z.number().optional(),
+  retries: z.number().optional(),
+  retryDelayMs: z.number().optional(),
+});
+
+const ToolRestrictionsSchema = z.object({
+  allow: z.array(z.string()).optional(),
+  deny: z.array(z.string()).optional(),
+});
+
+const ExecConfigSchema = z.object({
+  enabled: z.boolean().optional(),
+  allowlist: z.array(z.string()).optional(),
+  denylist: z.array(z.string()).optional(),
+  timeoutSeconds: z.number().optional(),
+  workDir: z.string().optional(),
+});
+
+const WebConfigSchema = z.object({
+  allowlist: z.array(z.string()).optional(),
+  denylist: z.array(z.string()).optional(),
+  timeoutSeconds: z.number().optional(),
+});
+
+const BrowserConfigSchema = z.object({
+  enabled: z.boolean().optional(),
+  browserPath: z.string().optional(),
+  headless: z.boolean().optional(),
+  timeoutSeconds: z.number().optional(),
+});
+
+const CanvasConfigSchema = z.object({
+  enabled: z.boolean().optional(),
+  port: z.number().optional(),
+});
+
+const SandboxConfigSchema = z.object({
+  dm: ToolRestrictionsSchema.optional(),
+  group: ToolRestrictionsSchema.optional(),
+});
+
+const ToolsConfigSchema = z.object({
+  allow: z.array(z.string()).optional(),
+  deny: z.array(z.string()).optional(),
+  exec: ExecConfigSchema.optional(),
+  web: WebConfigSchema.optional(),
+  browser: BrowserConfigSchema.optional(),
+  canvas: CanvasConfigSchema.optional(),
+  sandbox: SandboxConfigSchema.optional(),
+});
+
+const ContextConfigSchema = z.object({
+  maxTokens: z.number().optional(),
+  compactionThreshold: z.number().optional(),
+  minMessagesAfterCompaction: z.number().optional(),
+  maxCompactionRetries: z.number().optional(),
+});
+
+const AgentEntrySchema = z.object({
+  id: z.string(),
+  default: z.boolean().optional(),
+  workspace: z.string(),
+  description: z.string().optional(),
+});
+
+const AccountConfigSchema = z.object({
+  botToken: z.string().optional(),
+  applicationId: z.string().optional(),
+  appToken: z.string().optional(),
+  signingSecret: z.string().optional(),
+  dmPolicy: DMPolicySchema.optional(),
+  allowFrom: z.array(z.string()).optional(),
+});
+
+const ChannelConfigSchema = z.object({
+  enabled: z.boolean().optional(),
+  accounts: z.record(z.string(), AccountConfigSchema).optional(),
+  dmPolicy: DMPolicySchema.optional(),
+  allowFrom: z.array(z.string()).optional(),
+  groups: z.boolean().optional(),
+  guilds: z.record(z.string(), z.unknown()).optional(),
+  experimental: z.boolean().optional(),
+});
+
+const PeerMatchSchema = z.object({
+  kind: z.enum(["direct", "group"]).optional(),
+  id: z.string().optional(),
+});
+
+const BindingMatchSchema = z.object({
+  channel: z.string().optional(),
+  accountId: z.string().optional(),
+  peer: PeerMatchSchema.optional(),
+  guildId: z.string().optional(),
+  teamId: z.string().optional(),
+  roles: z.array(z.string()).optional(),
+});
+
+const BindingSchema = z.object({
+  agentId: z.string(),
+  match: BindingMatchSchema,
+});
+
+const MCPServerConfigSchema = z.object({
+  enabled: z.boolean().optional(),
+  transport: TransportSchema,
+  command: z.string().optional(),
+  args: z.array(z.string()).optional(),
+  env: z.record(z.string(), z.string()).optional(),
+  url: z.string().optional(),
+  headers: z.record(z.string(), z.string()).optional(),
+  reconnect: z.object({
+    enabled: z.boolean().optional(),
+    maxRetries: z.number().optional(),
+    delayMs: z.number().optional(),
+    backoffMultiplier: z.number().optional(),
+  }).optional(),
+});
+
+const MCPConfigSchema = z.object({
+  enabled: z.boolean().optional(),
+  servers: z.record(z.string(), MCPServerConfigSchema).optional(),
+  healthCheck: z.object({
+    enabled: z.boolean().optional(),
+    intervalSeconds: z.number().optional(),
+  }).optional(),
+});
+
+const EpisodicMemoryConfigSchema = z.object({
+  enabled: z.boolean().optional(),
+  provider: z.enum(["openai", "local"]).optional(),
+  maxEpisodesPerSession: z.number().optional(),
+});
+
+const MemoryConfigSchema = z.object({
+  dbPath: z.string().optional(),
+  notesDir: z.string().optional(),
+  episodic: EpisodicMemoryConfigSchema.optional(),
+});
+
+const CronConfigSchema = z.object({
+  enabled: z.boolean().optional(),
+  dbPath: z.string().optional(),
+  maxConcurrentJobs: z.number().optional(),
+  timezone: z.string().optional(),
+});
+
+const RetryConfigSchema = z.object({
+  maxAttempts: z.number().optional(),
+  initialDelayMs: z.number().optional(),
+  backoffMultiplier: z.number().optional(),
+  maxDelayMs: z.number().optional(),
+});
+
+const HooksConfigSchema = z.object({
+  scripts: z.object({
+    before_model_resolve: z.string().optional(),
+    before_prompt_build: z.string().optional(),
+    before_tool_call: z.string().optional(),
+    after_tool_call: z.string().optional(),
+    tool_result_persist: z.string().optional(),
+    before_compaction: z.string().optional(),
+    after_compaction: z.string().optional(),
+    message_received: z.string().optional(),
+    message_sending: z.string().optional(),
+    message_sent: z.string().optional(),
+    session_start: z.string().optional(),
+    session_end: z.string().optional(),
+    gateway_start: z.string().optional(),
+    gateway_stop: z.string().optional(),
+  }).optional(),
+});
+
+const LoggingConfigSchema = z.object({
+  level: LogLevelSchema.optional(),
+  dir: z.string().optional(),
+  maxSizeMB: z.number().optional(),
+  maxFiles: z.number().optional(),
+  redactSensitive: z.boolean().optional(),
+  console: z.boolean().optional(),
+});
+
+const GatewayConfigSchema = z.object({
+  host: z.string().optional(),
+  port: z.number().optional(),
+  authToken: z.string().optional(),
+  pidFile: z.string().optional(),
+  tools: ToolRestrictionsSchema.optional(),
+});
+
+const ModelsConfigSchema = z.object({
+  defaultProvider: z.enum(["openai", "anthropic", "gemini", "mistral", "kimi", "ollama", "openrouter", "deepseek"]).optional(),
+  defaults: z.record(z.string(), z.string()).optional(),
+  providers: z.record(z.string(), ProviderConfigSchema).optional(),
+});
+
+const SessionsConfigSchema = z.object({
+  dir: z.string().optional(),
+  pruneAfterHours: z.number().optional(),
+  maxTranscriptSizeMB: z.number().optional(),
+});
+
+const SkillsConfigSchema = z.object({
+  allowBundled: z.array(z.string()).optional(),
+  managedDir: z.string().optional(),
+  extraDirs: z.array(z.string()).optional(),
+  hotReload: z.boolean().optional(),
+  maxSkillSizeKB: z.number().optional(),
+});
+
+const SecurityConfigSchema = z.object({
+  maxMessageLength: z.record(z.string(), z.number()).optional(),
+  skillScanning: z.boolean().optional(),
+  warnOnInsecureConfig: z.boolean().optional(),
+  allowedUsers: z.array(z.string()).optional(),
+});
+
+const UserConfigSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  channels: z.record(z.string(), z.string()).optional(),
+});
+
+const ConfigSchema = z.object({
+  gateway: GatewayConfigSchema.optional(),
+  logging: LoggingConfigSchema.optional(),
+  user: UserConfigSchema.optional(),
+  agent: z.object({
+    defaultAgentId: z.string().optional(),
+    baseDir: z.string().optional(),
+    context: ContextConfigSchema.optional(),
+  }).optional(),
+  models: ModelsConfigSchema.optional(),
+  sessions: SessionsConfigSchema.optional(),
+  agents: z.object({
+    list: z.array(AgentEntrySchema).optional(),
+  }).optional(),
+  bindings: z.array(BindingSchema).optional(),
+  channels: z.record(z.string(), ChannelConfigSchema).optional(),
+  tools: ToolsConfigSchema.optional(),
+  skills: SkillsConfigSchema.optional(),
+  mcp: MCPConfigSchema.optional(),
+  memory: MemoryConfigSchema.optional(),
+  cron: CronConfigSchema.optional(),
+  retry: RetryConfigSchema.optional(),
+  security: SecurityConfigSchema.optional(),
+  hooks: HooksConfigSchema.optional(),
+});
+
+export type Config = z.infer<typeof ConfigSchema>;
+
+export type ProviderConfig = z.infer<typeof ProviderConfigSchema>;
+export type MCPServerConfig = z.infer<typeof MCPServerConfigSchema>;
+export type AgentEntry = z.infer<typeof AgentEntrySchema>;
+export type Binding = z.infer<typeof BindingSchema>;
+export type UserConfig = z.infer<typeof UserConfigSchema>;
+
+function buildDefaultConfig(): Config {
+  const hiveDir = getHiveDir();
+  return {
+    gateway: {
+      host: "127.0.0.1",
+      port: 18790,
+      pidFile: path.join(hiveDir, "gateway.pid"),
+      authToken: process.env.HIVE_AUTH_TOKEN || undefined,
+      tools: {
+        allow: ["*"],
+        deny: [],
+      },
+    },
+    logging: {
+      level: "info",
+      dir: path.join(hiveDir, "logs"),
+      maxSizeMB: 10,
+      maxFiles: 5,
+      redactSensitive: true,
+      console: true,
+    },
+    agent: {
+      defaultAgentId: "main",
+      baseDir: path.join(hiveDir, "agents"),
+      context: {
+        maxTokens: 0,
+        compactionThreshold: 0.8,
+        minMessagesAfterCompaction: 4,
+        maxCompactionRetries: 3,
+      },
+    },
+    models: {
+      defaultProvider: "openai",
+      defaults: {
+        openai: "gpt-4o",
+        anthropic: "claude-sonnet-4-20250514",
+        ollama: "llama3.2",
+        openrouter: "anthropic/claude-sonnet-4",
+      },
+      providers: {},
+    },
+    sessions: {
+      dir: path.join(hiveDir, "sessions"),
+      pruneAfterHours: 24,
+      maxTranscriptSizeMB: 50,
+    },
+    agents: {
+      list: [
+        {
+          id: "main",
+          default: true,
+          workspace: path.join(hiveDir, "agents", "main", "workspace"),
+          description: "Default personal assistant",
+        },
+      ],
+    },
+    bindings: [],
+    channels: {
+      webchat: { enabled: true },
+    },
+    tools: {
+      allow: ["*"],
+      deny: [],
+      exec: {
+        enabled: true,
+        allowlist: [],
+        denylist: ["rm -rf /", "sudo", "chmod 777", "> /dev/", "mkfs"],
+        timeoutSeconds: 30,
+        workDir: path.join(process.env.HOME || "", "exec"), // Points to home for exec by default
+      },
+      web: {
+        allowlist: [],
+        denylist: ["file://", "ftp://"],
+        timeoutSeconds: 30,
+      },
+      browser: {
+        enabled: true,
+        headless: true,
+        timeoutSeconds: 30,
+      },
+      canvas: {
+        enabled: true,
+        port: 18793,
+      },
+      sandbox: {
+        dm: { allow: ["*"], deny: [] },
+        group: { allow: ["*"], deny: [] },
+      },
+    },
+    skills: {
+      allowBundled: [],
+      managedDir: path.join(hiveDir, "skills"),
+      extraDirs: [],
+      hotReload: true,
+      maxSkillSizeKB: 100,
+    },
+    mcp: {
+      enabled: true,
+      servers: {},
+      healthCheck: {
+        enabled: true,
+        intervalSeconds: 60,
+      },
+    },
+    memory: {
+      dbPath: path.join(hiveDir, "memory.db"),
+      notesDir: path.join(hiveDir, "agents", "main", "workspace", "memory"),
+      episodic: {
+        enabled: false,
+        provider: "openai",
+        maxEpisodesPerSession: 100,
+      },
+    },
+    cron: {
+      enabled: true,
+      dbPath: path.join(hiveDir, "cron.db"),
+      maxConcurrentJobs: 5,
+      timezone: "UTC",
+    },
+    retry: {
+      maxAttempts: 3,
+      initialDelayMs: 1000,
+      backoffMultiplier: 2,
+      maxDelayMs: 30000,
+    },
+    security: {
+      maxMessageLength: {
+        telegram: 4096,
+        discord: 2000,
+        slack: 40000,
+        webchat: 100000,
+        whatsapp: 65536,
+      },
+      skillScanning: true,
+      warnOnInsecureConfig: true,
+    },
+    hooks: {
+      scripts: {},
+    },
+  };
+}
+
+
+// deepMerge kept for potential future use
+function deepMerge<T extends Record<string, unknown>>(target: T, source: Partial<T>): T {
+  const result = { ...target };
+
+  for (const key of Object.keys(source) as (keyof T)[]) {
+    const sourceValue = source[key];
+    const targetValue = result[key];
+
+    if (
+      sourceValue !== undefined &&
+      sourceValue !== null &&
+      typeof sourceValue === "object" &&
+      !Array.isArray(sourceValue) &&
+      targetValue !== undefined &&
+      targetValue !== null &&
+      typeof targetValue === "object" &&
+      !Array.isArray(targetValue)
+    ) {
+      result[key] = deepMerge(
+        targetValue as Record<string, unknown>,
+        sourceValue as Record<string, unknown>
+      ) as T[keyof T];
+    } else if (sourceValue !== undefined) {
+      result[key] = sourceValue as T[keyof T];
+    }
+  }
+
+  return result;
+}
+export function loadConfig(): Config {
+  return buildDefaultConfig();
+}
+
+export function expandConfigPath(p: string | undefined): string | undefined {
+  if (!p) return undefined;
+  return expandPath(p);
+}
+
+export { expandPath };

package/packages/core/src/events/event-bus.ts

@@ -0,0 +1,169 @@
+import { EventEmitter } from "events";
+import { logger } from "../utils/logger";
+
+export interface EventMap {
+  "message:received": {
+    channel: string;
+    userId: string;
+    content: string;
+    timestamp: number;
+    sessionId: string;
+  };
+  "message:sent": {
+    channel: string;
+    userId: string;
+    content: string;
+    messageId: string;
+    sessionId: string;
+  };
+  "agent:thinking": {
+    agentId: string;
+    sessionId: string;
+    stage: "planning" | "executing" | "responding";
+  };
+  "agent:response": {
+    agentId: string;
+    sessionId: string;
+    content: string;
+    toolsUsed: string[];
+    duration: number;
+  };
+  "tool:executing": {
+    toolName: string;
+    args: Record<string, unknown>;
+    sessionId: string;
+  };
+  "tool:completed": {
+    toolName: string;
+    result: unknown;
+    duration: number;
+    success: boolean;
+  };
+  "tool:error": {
+    toolName: string;
+    error: Error;
+    args: Record<string, unknown>;
+  };
+  "error": {
+    source: string;
+    error: Error;
+    context: Record<string, unknown>;
+    recoverable: boolean;
+  };
+  "session:started": {
+    sessionId: string;
+    agentId: string;
+    channel: string;
+    userId: string;
+  };
+  "session:ended": {
+    sessionId: string;
+    duration: number;
+    messageCount: number;
+    reason: "completed" | "cancelled" | "error" | "timeout";
+  };
+  "mcp:connected": {
+    serverName: string;
+    toolsCount: number;
+    resourcesCount: number;
+  };
+  "mcp:disconnected": {
+    serverName: string;
+    reason: string;
+  };
+  "mcp:error": {
+    serverName: string;
+    error: Error;
+  };
+  "channel:started": {
+    channel: string;
+    accountId: string;
+  };
+  "channel:stopped": {
+    channel: string;
+    accountId: string;
+    reason: string;
+  };
+  "gateway:started": {
+    host: string;
+    port: number;
+  };
+  "gateway:stopped": {
+    reason: string;
+  };
+  "pairing:requested": {
+    channel: string;
+    userId: string;
+    code: string;
+    expiresAt: number;
+  };
+  "pairing:approved": {
+    channel: string;
+    userId: string;
+  };
+  "pairing:rejected": {
+    channel: string;
+    userId: string;
+    reason: string;
+  };
+  "pairing:expired": {
+    code: string;
+    channel: string;
+    userId: string;
+  };
+}
+
+export type EventKey = keyof EventMap;
+
+export interface EventHandler<K extends EventKey> {
+  (data: EventMap[K]): void | Promise<void>;
+}
+
+class TypedEventBusImpl {
+  private emitter = new EventEmitter();
+  private logPrefix = "[events]";
+
+  emit<K extends EventKey>(event: K, data: EventMap[K]): void {
+    const enrichedData = {
+      ...data,
+      _eventId: crypto.randomUUID(),
+      _timestamp: Date.now(),
+      _event: event,
+    } as EventMap[K] & { _eventId: string; _timestamp: number; _event: string };
+
+    this.emitter.emit(event, enrichedData);
+
+    if (process.env.DEBUG_EVENTS === "true") {
+      logger.debug(`${this.logPrefix} emitted: ${event}`, { data });
+    }
+  }
+
+  on<K extends EventKey>(event: K, handler: EventHandler<K>): () => void {
+    this.emitter.on(event, handler);
+    return () => this.off(event, handler);
+  }
+
+  once<K extends EventKey>(event: K, handler: EventHandler<K>): void {
+    this.emitter.once(event, handler);
+  }
+
+  off<K extends EventKey>(event: K, handler: EventHandler<K>): void {
+    this.emitter.off(event, handler);
+  }
+
+  removeAllListeners<K extends EventKey>(event?: K): void {
+    if (event) {
+      this.emitter.removeAllListeners(event);
+    } else {
+      this.emitter.removeAllListeners();
+    }
+  }
+
+  listenerCount<K extends EventKey>(event: K): number {
+    return this.emitter.listenerCount(event);
+  }
+}
+
+export const eventBus = new TypedEventBusImpl();
+
+export type TypedEventBus = typeof eventBus;

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

@@ -0,0 +1,5 @@
+import { loadConfig } from "../config/loader.ts";
+import { startGateway } from "./server.ts";
+import { logger } from "../utils/logger.ts";
+
+export { loadConfig, startGateway, logger };