@johpaz/hive-sdk 0.0.12 → 0.0.15

package/packages/core/src/security/RateLimit.ts

@@ -0,0 +1,270 @@
+import { logger } from "../utils/logger.ts";
+
+export interface TokenBucketConfig {
+  maxTokens: number;
+  refillRate: number;
+  refillIntervalMs?: number;
+}
+
+export interface TokenBucket {
+  tokens: number;
+  lastUpdate: number;
+}
+
+export interface RateLimitResult {
+  allowed: boolean;
+  remaining: number;
+  retryAfterMs: number;
+}
+
+export interface TokenBucketStats {
+  totalBuckets: number;
+  activeBuckets: number;
+  totalTokensAvailable: number;
+}
+
+export class TokenBucketRateLimiter {
+  private buckets: Map<string, TokenBucket> = new Map();
+  private config: Required<TokenBucketConfig>;
+  private log = logger.child("token-bucket-limiter");
+
+  constructor(config: TokenBucketConfig) {
+    this.config = {
+      maxTokens: config.maxTokens,
+      refillRate: config.refillRate,
+      refillIntervalMs: config.refillIntervalMs ?? 1000,
+    };
+
+    this.startCleanup();
+  }
+
+  canProceed(key: string): RateLimitResult {
+    const now = Date.now();
+    let bucket = this.buckets.get(key);
+
+    if (!bucket) {
+      bucket = {
+        tokens: this.config.maxTokens,
+        lastUpdate: now,
+      };
+      this.buckets.set(key, bucket);
+    }
+
+    const elapsed = now - bucket.lastUpdate;
+    const tokensToAdd = (elapsed / this.config.refillIntervalMs) * this.config.refillRate;
+    bucket.tokens = Math.min(this.config.maxTokens, bucket.tokens + tokensToAdd);
+    bucket.lastUpdate = now;
+
+    if (bucket.tokens >= 1) {
+      bucket.tokens--;
+      return {
+        allowed: true,
+        remaining: Math.floor(bucket.tokens),
+        retryAfterMs: 0,
+      };
+    }
+
+    const retryAfterMs = Math.ceil(
+      ((1 - bucket.tokens) / this.config.refillRate) * this.config.refillIntervalMs
+    );
+
+    this.log.debug(`Rate limit hit for ${key}, retry after ${retryAfterMs}ms`);
+
+    return {
+      allowed: false,
+      remaining: 0,
+      retryAfterMs,
+    };
+  }
+
+  consume(key: string, tokens: number = 1): RateLimitResult {
+    const now = Date.now();
+    let bucket = this.buckets.get(key);
+
+    if (!bucket) {
+      bucket = {
+        tokens: this.config.maxTokens,
+        lastUpdate: now,
+      };
+      this.buckets.set(key, bucket);
+    }
+
+    const elapsed = now - bucket.lastUpdate;
+    const tokensToAdd = (elapsed / this.config.refillIntervalMs) * this.config.refillRate;
+    bucket.tokens = Math.min(this.config.maxTokens, bucket.tokens + tokensToAdd);
+    bucket.lastUpdate = now;
+
+    if (bucket.tokens >= tokens) {
+      bucket.tokens -= tokens;
+      return {
+        allowed: true,
+        remaining: Math.floor(bucket.tokens),
+        retryAfterMs: 0,
+      };
+    }
+
+    const retryAfterMs = Math.ceil(
+      ((tokens - bucket.tokens) / this.config.refillRate) * this.config.refillIntervalMs
+    );
+
+    return {
+      allowed: false,
+      remaining: 0,
+      retryAfterMs,
+    };
+  }
+
+  peek(key: string): number {
+    const bucket = this.buckets.get(key);
+    if (!bucket) return this.config.maxTokens;
+
+    const now = Date.now();
+    const elapsed = now - bucket.lastUpdate;
+    const tokensToAdd = (elapsed / this.config.refillIntervalMs) * this.config.refillRate;
+
+    return Math.min(this.config.maxTokens, bucket.tokens + tokensToAdd);
+  }
+
+  refill(key: string, tokens?: number): void {
+    const bucket = this.buckets.get(key);
+    if (!bucket) return;
+
+    bucket.tokens = Math.min(
+      this.config.maxTokens,
+      bucket.tokens + (tokens ?? this.config.maxTokens)
+    );
+  }
+
+  reset(key: string): void {
+    this.buckets.delete(key);
+  }
+
+  resetAll(): void {
+    this.buckets.clear();
+    this.log.info("All rate limit buckets cleared");
+  }
+
+  getStats(): TokenBucketStats {
+    let totalTokens = 0;
+    let activeBuckets = 0;
+    const now = Date.now();
+
+    for (const bucket of this.buckets.values()) {
+      const elapsed = now - bucket.lastUpdate;
+      const tokens = Math.min(
+        this.config.maxTokens,
+        bucket.tokens + (elapsed / this.config.refillIntervalMs) * this.config.refillRate
+      );
+
+      if (tokens < this.config.maxTokens) {
+        activeBuckets++;
+      }
+      totalTokens += tokens;
+    }
+
+    return {
+      totalBuckets: this.buckets.size,
+      activeBuckets,
+      totalTokensAvailable: Math.floor(totalTokens),
+    };
+  }
+
+  private startCleanup(): void {
+    setInterval(() => {
+      const now = Date.now();
+      for (const [key, bucket] of this.buckets) {
+        const elapsed = now - bucket.lastUpdate;
+        const fullTokens =
+          bucket.tokens + (elapsed / this.config.refillIntervalMs) * this.config.refillRate;
+
+        if (fullTokens >= this.config.maxTokens) {
+          this.buckets.delete(key);
+        }
+      }
+    }, 5 * 60 * 1000);
+  }
+}
+
+export interface SlidingWindowConfig {
+  windowMs: number;
+  maxRequests: number;
+}
+
+export interface SlidingWindowEntry {
+  timestamps: number[];
+}
+
+export class SlidingWindowRateLimiter {
+  private windows: Map<string, SlidingWindowEntry> = new Map();
+  private config: SlidingWindowConfig;
+  private log = logger.child("sliding-window-limiter");
+
+  constructor(config: SlidingWindowConfig) {
+    this.config = config;
+    this.startCleanup();
+  }
+
+  check(key: string): RateLimitResult {
+    const now = Date.now();
+    const windowStart = now - this.config.windowMs;
+
+    let entry = this.windows.get(key);
+    if (!entry) {
+      entry = { timestamps: [] };
+      this.windows.set(key, entry);
+    }
+
+    entry.timestamps = entry.timestamps.filter((t) => t > windowStart);
+
+    if (entry.timestamps.length >= this.config.maxRequests) {
+      const oldestInWindow = entry.timestamps[0];
+      const retryAfterMs = oldestInWindow + this.config.windowMs - now;
+
+      this.log.debug(`Sliding window limit hit for ${key}`);
+
+      return {
+        allowed: false,
+        remaining: 0,
+        retryAfterMs: Math.max(0, retryAfterMs),
+      };
+    }
+
+    entry.timestamps.push(now);
+
+    return {
+      allowed: true,
+      remaining: this.config.maxRequests - entry.timestamps.length,
+      retryAfterMs: 0,
+    };
+  }
+
+  reset(key: string): void {
+    this.windows.delete(key);
+  }
+
+  resetAll(): void {
+    this.windows.clear();
+  }
+
+  private startCleanup(): void {
+    setInterval(() => {
+      const now = Date.now();
+      const windowStart = now - this.config.windowMs;
+
+      for (const [key, entry] of this.windows) {
+        entry.timestamps = entry.timestamps.filter((t) => t > windowStart);
+        if (entry.timestamps.length === 0) {
+          this.windows.delete(key);
+        }
+      }
+    }, 60 * 1000);
+  }
+}
+
+export function createTokenBucketLimiter(config: TokenBucketConfig): TokenBucketRateLimiter {
+  return new TokenBucketRateLimiter(config);
+}
+
+export function createSlidingWindowLimiter(config: SlidingWindowConfig): SlidingWindowRateLimiter {
+  return new SlidingWindowRateLimiter(config);
+}

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

@@ -0,0 +1,4 @@
+export type { PairingCode, PairingConfig, PairingStats } from "./Pairing.ts";
+export { PairingService } from "./Pairing.ts";
+export type { TokenBucketConfig, TokenBucket, RateLimitResult, TokenBucketStats } from "./RateLimit.ts";
+export { TokenBucketRateLimiter } from "./RateLimit.ts";

package/packages/core/src/skills/SkillLoader.ts

@@ -0,0 +1,388 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { YAML } from "bun";
+
+// Static bundled data generated by packages/skills/scripts/generate-bundle.ts
+// Loaded at build time so it works inside dist/hive.js without FS access
+let STATIC_BUNDLED_DATA: Array<{
+  name: string; description: string; category: string; version: string;
+  tools: string[]; triggers: string[]; body: string;
+}> = [];
+try {
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  STATIC_BUNDLED_DATA = require("./bundled-data.generated").BUNDLED_SKILLS_DATA ?? [];
+} catch {
+  // Not generated yet (dev mode without running generate-bundle script) — FS scan used instead
+}
+
+export interface SkillsConfig {
+  allowBundled?: string[];
+  managedDir?: string;
+  extraDirs?: string[];
+  hotReload?: boolean;
+  maxSkillSizeKB?: number;
+}
+
+export interface Config {
+  skills?: SkillsConfig;
+  workspacePath?: string;
+}
+
+interface Logger {
+  debug: (msg: string, ...args: unknown[]) => void;
+  info: (msg: string, ...args: unknown[]) => void;
+  warn: (msg: string, ...args: unknown[]) => void;
+  error: (msg: string, ...args: unknown[]) => void;
+}
+
+function createLogger(): Logger {
+  return {
+    debug: (msg, ...args) => console.debug(`[skills] ${msg}`, ...args),
+    info: (msg, ...args) => console.info(`[skills] ${msg}`, ...args),
+    warn: (msg, ...args) => console.warn(`[skills] ${msg}`, ...args),
+    error: (msg, ...args) => console.error(`[skills] ${msg}`, ...args),
+  };
+}
+
+export interface SkillStep {
+  step: number;
+  action: string;
+  instruction: string;
+  output?: string;
+  params?: Record<string, any>;
+}
+
+export interface OutputFormat {
+  structure: "markdown" | "code" | "json" | "text";
+  language?: string;
+  sections?: string[];
+  max_length?: string;
+  include_diff?: boolean;
+}
+
+export interface SkillExample {
+  user_input: string;
+  expected_behavior: string;
+}
+
+export interface SkillMetadata {
+  name: string;
+  version?: string;
+  author?: string;
+  description: string;
+  icon?: string;
+  category?: string;
+  permissions?: string[];
+  dependencies?: string[];
+  tools?: string[];
+  
+  // Structured skill fields
+  triggers?: string[];              // Patrones de activación explícita
+  steps?: SkillStep[];              // Workflow secuenciado
+  rules?: string[];                 // Reglas de ejecución
+  output_format?: OutputFormat;     // Estructura de output esperado
+  preferred_agents?: string[];      // Agents preferidos para delegación
+  examples?: SkillExample[];        // Ejemplos de uso
+  
+  requirements?: {
+    os?: string[];
+    bins?: string[];
+    env?: string[];
+    config?: string[];
+  };
+  // Retrocompatibilidad con el campo metadata.hive previo
+  metadata?: {
+    hive?: {
+      emoji?: string;
+      bins?: string[];
+      userInvocable?: boolean;
+      requires?: {
+        config?: string[];
+        env?: string[];
+      };
+      install?: {
+        brew?: string;
+        apt?: string;
+        npm?: string;
+      };
+      os?: string[];
+    };
+  };
+}
+
+export interface Skill {
+  name: string;
+  description: string;
+  version?: string;
+  author?: string;
+  icon?: string;
+  category?: string;
+  content: string;
+  raw: string;
+  metadata: SkillMetadata;
+  source: "bundled" | "managed" | "workspace";
+  path: string;
+  permissions?: string[];
+  dependencies?: string[];
+  tools?: string[];
+  // Structured skill fields (parsed from frontmatter)
+  triggers?: string[];
+  steps?: SkillStep[];
+  rules?: string[];
+  output_format?: OutputFormat;
+  preferred_agents?: string[];
+  examples?: SkillExample[];
+}
+
+function parseFrontmatter(content: string): { frontmatter: Record<string, unknown>; body: string } {
+  const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+
+  if (!match) {
+    return { frontmatter: {}, body: content };
+  }
+
+  try {
+    const frontmatter = YAML.parse(match[1]!) as Record<string, unknown>;
+    const body = match[2]!;
+    return { frontmatter, body };
+  } catch {
+    return { frontmatter: {}, body: content };
+  }
+}
+
+export class SkillLoader {
+  private config: Config;
+  private log: Logger;
+  private cache: Map<string, Skill> = new Map();
+  private bundledDir: string;
+
+  constructor(config: Config) {
+    this.config = config;
+    this.log = createLogger();
+    this.bundledDir = path.join(__dirname, "bundled");
+  }
+
+  private expandPath(p: string): string {
+    if (p.startsWith("~")) {
+      return path.join(process.env.HOME ?? "", p.slice(1));
+    }
+    return p;
+  }
+
+  loadSkill(skillPath: string, source: Skill["source"]): Skill | null {
+    try {
+      const skillMdPath = path.join(skillPath, "SKILL.md");
+
+      if (!fs.existsSync(skillMdPath)) {
+        return null;
+      }
+
+      const content = fs.readFileSync(skillMdPath, "utf-8");
+      const { frontmatter, body } = parseFrontmatter(content);
+
+      const rawMetadata = (frontmatter.metadata as any) ?? {};
+      const hiveMetadata = rawMetadata.hive ?? {};
+
+      const name = (frontmatter.name as string) ?? path.basename(skillPath);
+      const description = (frontmatter.description as string) ?? "";
+      const version = (frontmatter.version as string) ?? "0.0.1";
+      const author = (frontmatter.author as string) ?? "Anonymous";
+      const icon = (frontmatter.icon as string) ?? hiveMetadata.emoji ?? "🧩";
+      const category = (frontmatter.category as string) ?? "general";
+
+      const permissions = (frontmatter.permissions as string[]) ?? [];
+      const dependencies = (frontmatter.dependencies as string[]) ?? [];
+      const tools = (frontmatter.tools as string[]) ?? [];
+      
+      // Structured skill fields
+      const triggers = (frontmatter.triggers as string[]) ?? [];
+      const steps = (frontmatter.steps as SkillStep[]) ?? [];
+      const rules = (frontmatter.rules as string[]) ?? [];
+      const output_format = (frontmatter.output_format as OutputFormat) ?? undefined;
+      const preferred_agents = (frontmatter.preferred_agents as string[]) ?? [];
+      const examples = (frontmatter.examples as SkillExample[]) ?? [];
+
+      const metadata: SkillMetadata = {
+        ...(frontmatter as any),
+        name,
+        description,
+        version,
+        author,
+        icon,
+        category,
+        permissions,
+        dependencies,
+        tools,
+        triggers,
+        steps,
+        rules,
+        output_format,
+        preferred_agents,
+        examples
+      };
+
+      const skill: Skill = {
+        name,
+        description,
+        version,
+        author,
+        icon,
+        category,
+        content: body,
+        raw: content,
+        metadata,
+        source,
+        path: skillPath,
+        permissions,
+        dependencies,
+        tools,
+        triggers,
+        steps,
+        rules,
+        output_format,
+        preferred_agents,
+        examples
+      };
+
+      this.cache.set(name, skill);
+      return skill;
+    } catch (error) {
+      this.log.error(`Failed to load skill: ${skillPath}`, { error: (error as Error).message });
+      return null;
+    }
+  }
+
+  loadBundledSkills(): Skill[] {
+    // Use static pre-generated data when available (production bundle, dist/hive.js)
+    if (STATIC_BUNDLED_DATA.length > 0) {
+      const skills: Skill[] = STATIC_BUNDLED_DATA.map((entry) => ({
+        name: entry.name,
+        description: entry.description,
+        version: entry.version,
+        author: "Hive",
+        icon: "🧩",
+        category: entry.category,
+        content: entry.body,
+        raw: entry.body,
+        metadata: {
+          name: entry.name,
+          description: entry.description,
+          version: entry.version,
+          category: entry.category,
+          tools: entry.tools,
+          triggers: entry.triggers,
+        },
+        source: "bundled" as const,
+        path: "",
+        tools: entry.tools,
+        triggers: entry.triggers,
+      }));
+      this.log.debug(`Loaded ${skills.length} bundled skills from static data`);
+      return skills;
+    }
+
+    // Fallback: FS scan for development (before generate-bundle is run)
+    const skills: Map<string, Skill> = new Map();
+
+    if (!fs.existsSync(this.bundledDir)) {
+      this.log.debug(`Bundled skills directory not found: ${this.bundledDir}`);
+      return [];
+    }
+
+    const scanDir = (dir: string) => {
+      for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        if (!entry.isDirectory()) continue;
+        const entryPath = path.join(dir, entry.name);
+        if (fs.existsSync(path.join(entryPath, "SKILL.md"))) {
+          const skill = this.loadSkill(entryPath, "bundled");
+          if (skill) skills.set(skill.name, skill);
+        } else {
+          // Es un directorio de categoría — bajar un nivel más
+          scanDir(entryPath);
+        }
+      }
+    };
+
+    scanDir(this.bundledDir);
+
+    this.log.debug(`Loaded ${skills.size} bundled skills from filesystem`);
+    return Array.from(skills.values());
+  }
+
+  loadAllSkills(): Skill[] {
+    const skills: Map<string, Skill> = new Map();
+    const allowBundled = this.config.skills?.allowBundled;
+
+    // 1. Load bundled skills (lowest priority)
+    const bundledSkills = this.loadBundledSkills();
+    for (const skill of bundledSkills) {
+      // If allowBundled is undefined, empty, or contains the skill name, include it
+      if (!allowBundled || allowBundled.length === 0 || allowBundled.includes(skill.name)) {
+        skills.set(skill.name, skill);
+      }
+    }
+
+    // 2. Load managed skills (medium priority)
+    const managedDir = this.expandPath(this.config.skills?.managedDir ?? "~/.hive/skills");
+    if (fs.existsSync(managedDir)) {
+      for (const entry of fs.readdirSync(managedDir, { withFileTypes: true })) {
+        if (entry.isDirectory()) {
+          const skill = this.loadSkill(path.join(managedDir, entry.name), "managed");
+          if (skill) {
+            skills.set(skill.name, skill);
+          }
+        }
+      }
+    }
+
+    // 3. Load extra directories
+    const extraDirs = this.config.skills?.extraDirs ?? [];
+    for (const extraDir of extraDirs) {
+      const expandedDir = this.expandPath(extraDir);
+      if (fs.existsSync(expandedDir)) {
+        for (const entry of fs.readdirSync(expandedDir, { withFileTypes: true })) {
+          if (entry.isDirectory()) {
+            const skill = this.loadSkill(path.join(expandedDir, entry.name), "managed");
+            if (skill) {
+              skills.set(skill.name, skill);
+            }
+          }
+        }
+      }
+    }
+
+    // 4. Load workspace skills (highest priority)
+    const workspacePath = this.config.workspacePath ?? process.cwd();
+    const workspaceSkillsDir = path.join(workspacePath, "skills");
+    if (fs.existsSync(workspaceSkillsDir)) {
+      for (const entry of fs.readdirSync(workspaceSkillsDir, { withFileTypes: true })) {
+        if (entry.isDirectory()) {
+          const skill = this.loadSkill(path.join(workspaceSkillsDir, entry.name), "workspace");
+          if (skill) {
+            skills.set(skill.name, skill);
+          }
+        }
+      }
+    }
+
+    this.log.info(`Loaded ${skills.size} total skills`);
+    return Array.from(skills.values());
+  }
+
+  getSkill(name: string): Skill | undefined {
+    return this.cache.get(name);
+  }
+
+  listSkills(): string[] {
+    return Array.from(this.cache.keys());
+  }
+
+  clearCache(): void {
+    this.cache.clear();
+  }
+}
+
+export function createSkillLoader(config: Config): SkillLoader {
+  return new SkillLoader(config);
+}
+