@johpaz/hive-core 0.1.1

package/src/config/loader.ts

@@ -0,0 +1,508 @@
+import * as z from "zod";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as yaml from "js-yaml";
+
+const LogLevelSchema = z.enum(["debug", "info", "warn", "error"]);
+const DMPolicySchema = z.enum(["open", "pairing", "allowlist"]);
+const TransportSchema = z.enum(["stdio", "sse", "websocket"]);
+
+const expandPath = (p: string): string => {
+  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", "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 ConfigSchema = z.object({
+  gateway: GatewayConfigSchema.optional(),
+  logging: LoggingConfigSchema.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>;
+
+const DEFAULT_CONFIG: Config = {
+  gateway: {
+    host: "127.0.0.1",
+    port: 18790,
+    pidFile: "~/.hive/gateway.pid",
+    tools: {
+      allow: [],
+      deny: ["exec", "write", "edit", "apply_patch"],
+    },
+  },
+  logging: {
+    level: "info",
+    dir: "~/.hive/logs",
+    maxSizeMB: 10,
+    maxFiles: 5,
+    redactSensitive: true,
+    console: true,
+  },
+  agent: {
+    defaultAgentId: "main",
+    baseDir: "~/.hive/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: "~/.hive/sessions",
+    pruneAfterHours: 24,
+    maxTranscriptSizeMB: 50,
+  },
+  agents: {
+    list: [
+      {
+        id: "main",
+        default: true,
+        workspace: "~/.hive/agents/main/workspace",
+        description: "Default personal assistant",
+      },
+    ],
+  },
+  bindings: [],
+  channels: {
+    webchat: { enabled: true },
+  },
+  tools: {
+    allow: ["read", "web_search", "web_fetch", "notify"],
+    deny: [],
+    exec: {
+      enabled: false,
+      allowlist: [],
+      denylist: ["rm -rf /", "sudo", "chmod 777", "> /dev/", "mkfs"],
+      timeoutSeconds: 30,
+      workDir: "~/.hive/exec",
+    },
+    web: {
+      allowlist: [],
+      denylist: ["file://", "ftp://"],
+      timeoutSeconds: 30,
+    },
+    browser: {
+      enabled: false,
+      headless: true,
+      timeoutSeconds: 30,
+    },
+    canvas: {
+      enabled: false,
+      port: 18793,
+    },
+    sandbox: {
+      dm: { deny: ["exec", "write", "edit", "apply_patch"] },
+      group: { deny: ["exec", "write", "edit", "apply_patch"] },
+    },
+  },
+  skills: {
+    allowBundled: [
+      "web_search",
+      "shell",
+      "file_manager",
+      "http_client",
+      "memory",
+      "cron_manager",
+      "system_notify",
+      "browser_automation",
+      "context_compact",
+    ],
+    managedDir: "~/.hive/skills",
+    extraDirs: [],
+    hotReload: true,
+    maxSkillSizeKB: 100,
+  },
+  mcp: {
+    enabled: true,
+    servers: {},
+    healthCheck: {
+      enabled: true,
+      intervalSeconds: 60,
+    },
+  },
+  memory: {
+    dbPath: "~/.hive/memory.db",
+    notesDir: "~/.hive/agents/main/workspace/memory",
+    episodic: {
+      enabled: false,
+      provider: "openai",
+      maxEpisodesPerSession: 100,
+    },
+  },
+  cron: {
+    enabled: true,
+    dbPath: "~/.hive/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: {},
+  },
+};
+
+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(configPath?: string): Config {
+  const paths = configPath
+    ? [configPath]
+    : [
+        path.join(process.cwd(), "CONFIG.yaml"),
+        path.join(process.cwd(), "config.yaml"),
+        path.join(process.env.HOME || "", ".hive", "CONFIG.yaml"),
+      ];
+
+  let loadedConfig: Partial<Config> = {};
+
+  for (const p of paths) {
+    if (fs.existsSync(p)) {
+      try {
+        const content = fs.readFileSync(p, "utf-8");
+        const parsed = yaml.load(content);
+        loadedConfig = expandEnvInObject(parsed as Partial<Config>);
+        break;
+      } catch (error) {
+        throw new Error(`Failed to parse config file ${p}: ${error}`);
+      }
+    }
+  }
+
+  const merged = deepMerge(DEFAULT_CONFIG, loadedConfig);
+  
+  const result = ConfigSchema.safeParse(merged);
+  if (!result.success) {
+    throw new Error(`Invalid configuration: ${result.error.message}`);
+  }
+
+  return result.data;
+}
+
+export function expandConfigPath(p: string | undefined): string | undefined {
+  if (!p) return undefined;
+  return expandPath(p);
+}
+
+export { expandPath };

package/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 };

package/src/gateway/lane-queue.ts

@@ -0,0 +1,169 @@
+export type TaskStatus = "pending" | "running" | "completed" | "failed" | "cancelled";
+
+export interface Task {
+  id: string;
+  sessionId: string;
+  status: TaskStatus;
+  priority: number;
+  createdAt: Date;
+  startedAt?: Date;
+  completedAt?: Date;
+  error?: string;
+  abortController: AbortController;
+}
+
+export interface LaneQueueOptions {
+  maxConcurrency?: number;
+  taskTimeoutMs?: number;
+}
+
+type TaskHandler<T> = (task: Task, signal: AbortSignal) => Promise<T>;
+
+export class LaneQueue {
+  private queues: Map<string, Task[]> = new Map();
+  private running: Map<string, Task> = new Map();
+  private handlers: Map<string, TaskHandler<unknown>> = new Map();
+  private taskIdCounter = 0;
+  private options: Required<LaneQueueOptions>;
+
+  constructor(options: LaneQueueOptions = {}) {
+    this.options = {
+      maxConcurrency: options.maxConcurrency ?? 1,
+      taskTimeoutMs: options.taskTimeoutMs ?? 300000,
+    };
+  }
+
+  private generateTaskId(): string {
+    return `task-${Date.now()}-${++this.taskIdCounter}`;
+  }
+
+  private getQueue(sessionId: string): Task[] {
+    let queue = this.queues.get(sessionId);
+    if (!queue) {
+      queue = [];
+      this.queues.set(sessionId, queue);
+    }
+    return queue;
+  }
+
+  enqueue<T>(
+    sessionId: string,
+    handler: TaskHandler<T>,
+    priority = 0
+  ): Task {
+    const task: Task = {
+      id: this.generateTaskId(),
+      sessionId,
+      status: "pending",
+      priority,
+      createdAt: new Date(),
+      abortController: new AbortController(),
+    };
+
+    this.handlers.set(task.id, handler as TaskHandler<unknown>);
+
+    const queue = this.getQueue(sessionId);
+    queue.push(task);
+    queue.sort((a, b) => b.priority - a.priority);
+
+    this.processQueue(sessionId);
+
+    return task;
+  }
+
+  private async processQueue(sessionId: string): Promise<void> {
+    const running = this.running.get(sessionId);
+    if (running) {
+      return;
+    }
+
+    const queue = this.getQueue(sessionId);
+    if (queue.length === 0) {
+      return;
+    }
+
+    const task = queue.shift();
+    if (!task) return;
+
+    task.status = "running";
+    task.startedAt = new Date();
+    this.running.set(sessionId, task);
+
+    const handler = this.handlers.get(task.id);
+
+    const timeoutId = setTimeout(() => {
+      task.abortController.abort();
+    }, this.options.taskTimeoutMs);
+
+    try {
+      if (handler) {
+        await handler(task, task.abortController.signal);
+      }
+      task.status = "completed";
+      task.completedAt = new Date();
+    } catch (error) {
+      if ((error as Error).name === "AbortError") {
+        task.status = "cancelled";
+      } else {
+        task.status = "failed";
+        task.error = (error as Error).message;
+      }
+      task.completedAt = new Date();
+    } finally {
+      clearTimeout(timeoutId);
+      this.running.delete(sessionId);
+      this.handlers.delete(task.id);
+      
+      if (queue.length > 0) {
+        this.processQueue(sessionId);
+      }
+    }
+  }
+
+  cancel(sessionId: string): boolean {
+    const task = this.running.get(sessionId);
+    if (task) {
+      task.abortController.abort();
+      return true;
+    }
+
+    const queue = this.getQueue(sessionId);
+    const index = queue.findIndex((t) => t.status === "pending");
+    if (index >= 0) {
+      const cancelled = queue.splice(index, 1)[0];
+      if (cancelled) {
+        cancelled.status = "cancelled";
+        cancelled.completedAt = new Date();
+      }
+      return true;
+    }
+
+    return false;
+  }
+
+  getStatus(sessionId: string): {
+    queueLength: number;
+    running?: Task;
+  } {
+    const queue = this.getQueue(sessionId);
+    const running = this.running.get(sessionId);
+
+    return {
+      queueLength: queue.length,
+      running,
+    };
+  }
+
+  isProcessing(sessionId: string): boolean {
+    return this.running.has(sessionId);
+  }
+
+  prune(sessionId: string): void {
+    const queue = this.getQueue(sessionId);
+    if (queue.length === 0 && !this.running.has(sessionId)) {
+      this.queues.delete(sessionId);
+    }
+  }
+}
+
+export const laneQueue = new LaneQueue();