@johpaz/hive 1.1.0

package/packages/core/src/integrations/catalog.ts

@@ -0,0 +1,286 @@
+export type TransportType = "stdio" | "sse"
+export type Category = "code" | "deploy" | "database" | "productivity"
+
+export interface Integration {
+  id: string
+  name: string
+  description: string
+  example: string
+  category: Category
+  mcp: {
+    transport: TransportType
+    command?: string
+    args?: string[]
+    envVar?: string
+    envVarLabel?: string
+    url?: string
+  }
+  requires?: {
+    command: string
+    installHint: string
+  }
+  tokenInstructions: string
+  tokenValidation?: {
+    url: string
+    method?: "GET" | "POST"
+    headers: (token: string) => Record<string, string>
+    body?: (token: string) => string
+    getUsername: (response: any) => string
+  }
+  tokenFormat?: RegExp
+}
+
+export const INTEGRATIONS: Integration[] = [
+
+  // ── CÓDIGO ────────────────────────────────────────────────────────────
+
+  {
+    id: "github",
+    name: "GitHub",
+    description: "Repositorios y control de versiones",
+    example:
+      "Bee puede crear repositorios, guardar cambios, " +
+      "abrir pull requests y gestionar issues.",
+    category: "code",
+    mcp: {
+      transport: "stdio",
+      command: "npx",
+      args: ["-y", "@modelcontextprotocol/server-github"],
+      envVar: "GITHUB_TOKEN",
+      envVarLabel: "Token de GitHub",
+    },
+    tokenInstructions:
+      "1. Ve a github.com → tu foto → Settings\n" +
+      "2. Baja hasta Developer settings → Personal access tokens → Tokens (classic)\n" +
+      "3. Generate new token (classic)\n" +
+      "4. Marca: repo ✓  workflow ✓  read:org ✓\n" +
+      "5. Generate token → copiarlo aquí",
+    tokenValidation: {
+      url: "https://api.github.com/user",
+      headers: (t) => ({ Authorization: `Bearer ${t}` }),
+      getUsername: (r) => `@${r.login}`,
+    },
+    tokenFormat: /^(ghp_|github_pat_).{10,}/,
+  },
+
+  {
+    id: "gitlab",
+    name: "GitLab",
+    description: "Alternativa a GitHub para repositorios",
+    example:
+      "Igual que GitHub pero en GitLab. " +
+      "Ideal si tu empresa usa GitLab.",
+    category: "code",
+    mcp: {
+      transport: "stdio",
+      command: "npx",
+      args: ["-y", "@modelcontextprotocol/server-gitlab"],
+      envVar: "GITLAB_TOKEN",
+      envVarLabel: "Token de GitLab",
+    },
+    tokenInstructions:
+      "1. Ve a gitlab.com → tu avatar → Edit profile\n" +
+      "2. Access Tokens → Add new token\n" +
+      "3. Permisos: api ✓  read_user ✓  read_repository ✓\n" +
+      "4. Create personal access token → copiarlo aquí",
+    tokenValidation: {
+      url: "https://gitlab.com/api/v4/user",
+      headers: (t) => ({ "PRIVATE-TOKEN": t }),
+      getUsername: (r) => `@${r.username}`,
+    },
+    tokenFormat: /^glpat-.{10,}/,
+  },
+
+  // ── DEPLOY ────────────────────────────────────────────────────────────
+
+  {
+    id: "vercel",
+    name: "Vercel",
+    description: "Publicar sitios web en internet",
+    example:
+      "Bee puede publicar tu proyecto con un mensaje, " +
+      "ver el estado del sitio y revisar los logs.",
+    category: "deploy",
+    mcp: {
+      transport: "stdio",
+      command: "npx",
+      args: ["-y", "@vercel/mcp-adapter"],
+      envVar: "VERCEL_TOKEN",
+      envVarLabel: "Token de Vercel",
+    },
+    tokenInstructions:
+      "1. Ve a vercel.com → tu avatar → Settings → Tokens\n" +
+      "2. Create Token\n" +
+      "3. Nombre: 'hive', Scope: Full Account\n" +
+      "4. Copiarlo aquí",
+    tokenValidation: {
+      url: "https://api.vercel.com/v2/user",
+      headers: (t) => ({ Authorization: `Bearer ${t}` }),
+      getUsername: (r) => r.user?.email ?? "cuenta verificada",
+    },
+  },
+
+  {
+    id: "netlify",
+    name: "Netlify",
+    description: "Publicar sitios web (alternativa a Vercel)",
+    example:
+      "Bee puede crear proyectos en Netlify, hacer deployments " +
+      "y gestionar variables de entorno.",
+    category: "deploy",
+    mcp: {
+      transport: "stdio",
+      command: "npx",
+      args: ["-y", "@netlify/mcp"],
+      envVar: "NETLIFY_TOKEN",
+      envVarLabel: "Token de Netlify",
+    },
+    tokenInstructions:
+      "1. Ve a app.netlify.com → tu avatar → User settings\n" +
+      "2. Applications → Personal access tokens → New access token\n" +
+      "3. Descripción: 'hive' → copiarlo aquí",
+    tokenValidation: {
+      url: "https://api.netlify.com/api/v1/user",
+      headers: (t) => ({ Authorization: `Bearer ${t}` }),
+      getUsername: (r) => r.email ?? "cuenta verificada",
+    },
+  },
+
+  {
+    id: "railway",
+    name: "Railway",
+    description: "Desplegar aplicaciones y bases de datos en la nube",
+    example:
+      "Bee puede crear proyectos en Railway, hacer deployments " +
+      "y gestionar variables de entorno de tus servicios.",
+    category: "deploy",
+    mcp: {
+      transport: "stdio",
+      command: "npx",
+      args: ["-y", "@railway/mcp-server"],
+      envVar: "RAILWAY_TOKEN",
+      envVarLabel: "Token de Railway",
+    },
+    requires: {
+      command: "railway",
+      installHint:
+        "Railway requiere su CLI instalado en tu sistema.\n" +
+        "Instálalo con:  npm install -g @railway/cli\n" +
+        "Luego:          railway login",
+    },
+    tokenInstructions:
+      "1. Ve a railway.app → tu avatar → Account Settings → Tokens\n" +
+      "2. Create Token → nombre: 'hive'\n" +
+      "3. Copiarlo aquí\n\n" +
+      "⚠️  También necesitas el Railway CLI:\n" +
+      "    npm install -g @railway/cli\n" +
+      "    railway login",
+    tokenValidation: {
+      url: "https://backboard.railway.app/graphql/v2",
+      method: "POST",
+      headers: (t) => ({
+        Authorization: `Bearer ${t}`,
+        "Content-Type": "application/json",
+      }),
+      body: () => JSON.stringify({ query: "{ me { email } }" }),
+      getUsername: (r) => r.data?.me?.email ?? "cuenta verificada",
+    },
+  },
+
+  // ── DATABASE ──────────────────────────────────────────────────────────
+
+  {
+    id: "supabase",
+    name: "Supabase",
+    description: "Base de datos para tus aplicaciones",
+    example:
+      "Bee puede crear tablas, consultar datos y gestionar " +
+      "la autenticación de usuarios en Supabase.",
+    category: "database",
+    mcp: {
+      transport: "stdio",
+      command: "npx",
+      args: ["-y", "@supabase/mcp-server-supabase"],
+      envVar: "SUPABASE_ACCESS_TOKEN",
+      envVarLabel: "Token de Supabase",
+    },
+    tokenInstructions:
+      "1. Ve a supabase.com → tu avatar → Account → Access Tokens\n" +
+      "2. Generate new token → nombre: 'hive'\n" +
+      "3. Copiarlo aquí",
+    tokenValidation: {
+      url: "https://api.supabase.com/v1/projects",
+      headers: (t) => ({ Authorization: `Bearer ${t}` }),
+      getUsername: (_r) => "cuenta verificada",
+    },
+  },
+
+  // ── PRODUCTIVIDAD ─────────────────────────────────────────────────────
+
+  {
+    id: "notion",
+    name: "Notion",
+    description: "Documentos, wikis y bases de conocimiento",
+    example:
+      "Bee puede crear páginas, actualizar documentos " +
+      "y leer tu base de conocimiento en Notion.",
+    category: "productivity",
+    mcp: {
+      transport: "stdio",
+      command: "npx",
+      args: ["-y", "@notionhq/notion-mcp-server"],
+      envVar: "NOTION_API_TOKEN",
+      envVarLabel: "Token de Notion",
+    },
+    tokenInstructions:
+      "1. Ve a notion.so/my-integrations\n" +
+      "2. New integration → nombre: 'hive'\n" +
+      "3. Permisos: Read ✓  Update ✓  Insert ✓\n" +
+      "4. Submit → copiar 'Internal Integration Token'\n\n" +
+      "⚠️  Para cada página que quieras que Bee lea:\n" +
+      "    Abre la página → '...' → Connections → 'hive'",
+    tokenValidation: {
+      url: "https://api.notion.com/v1/users/me",
+      headers: (t) => ({
+        Authorization: `Bearer ${t}`,
+        "Notion-Version": "2022-06-28",
+      }),
+      getUsername: (r) => r.name ?? "bot verificado",
+    },
+    tokenFormat: /^secret_.{40,}/,
+  },
+
+  {
+    id: "linear",
+    name: "Linear",
+    description: "Gestión de tareas y proyectos de desarrollo",
+    example:
+      "Bee puede crear issues, actualizar tareas y hacer " +
+      "seguimiento del progreso en Linear.",
+    category: "productivity",
+    mcp: {
+      transport: "sse",
+      url: "https://mcp.linear.app/sse",
+    },
+    tokenInstructions:
+      "Linear usa autenticación automática (OAuth).\n" +
+      "No necesitas copiar ningún token.\n" +
+      "Cuando Bee use Linear por primera vez, te pedirá\n" +
+      "que autorices el acceso desde tu navegador.",
+  },
+
+]
+
+export function getIntegration(id: string): Integration | undefined {
+  return INTEGRATIONS.find(i => i.id === id)
+}
+
+export function getIntegrationsByCategory(): Map<Category, Integration[]> {
+  const map = new Map<Category, Integration[]>()
+  for (const i of INTEGRATIONS) {
+    const list = map.get(i.category) ?? []
+    list.push(i)
+    map.set(i.category, list)
+  }
+  return map
+}

package/packages/core/src/integrations/env.ts

@@ -0,0 +1,64 @@
+import * as fs from "node:fs"
+import * as path from "node:path"
+
+const ENV_PATH = path.join(process.env.HOME ?? "~", ".hive", ".env")
+
+export function saveToken(key: string, value: string): void {
+  let content = ""
+
+  if (fs.existsSync(ENV_PATH)) {
+    content = fs.readFileSync(ENV_PATH, "utf-8")
+    if (new RegExp(`^${key}=`, "m").test(content)) {
+      content = content.replace(new RegExp(`^${key}=.*$`, "m"), `${key}=${value}`)
+      fs.writeFileSync(ENV_PATH, content)
+      fs.chmodSync(ENV_PATH, 0o600)
+      return
+    }
+  }
+
+  fs.mkdirSync(path.dirname(ENV_PATH), { recursive: true })
+  fs.appendFileSync(ENV_PATH, `${key}=${value}\n`)
+  fs.chmodSync(ENV_PATH, 0o600)
+}
+
+export function removeToken(key: string): void {
+  if (!fs.existsSync(ENV_PATH)) return
+  const content = fs.readFileSync(ENV_PATH, "utf-8")
+  const updated = content
+    .split("\n")
+    .filter(line => !line.startsWith(`${key}=`))
+    .join("\n")
+  fs.writeFileSync(ENV_PATH, updated)
+}
+
+export function loadHiveEnv(): Record<string, string> {
+  const loaded: Record<string, string> = {}
+  if (!fs.existsSync(ENV_PATH)) return loaded
+
+  for (const line of fs.readFileSync(ENV_PATH, "utf-8").split("\n")) {
+    const trimmed = line.trim()
+    if (!trimmed || trimmed.startsWith("#")) continue
+    const eq = trimmed.indexOf("=")
+    if (eq === -1) continue
+    const key   = trimmed.slice(0, eq).trim()
+    const value = trimmed.slice(eq + 1).trim()
+    if (key && value && !process.env[key]) {
+      process.env[key] = value
+      loaded[key] = value
+    }
+  }
+  return loaded
+}
+
+export function resolveEnvVars(obj: Record<string, string>): Record<string, string> {
+  return Object.fromEntries(
+    Object.entries(obj).map(([k, v]) => [
+      k,
+      v.replace(/\$\{(\w+)\}/g, (_, name) => process.env[name] ?? ""),
+    ])
+  )
+}
+
+export function getEnvPath(): string {
+  return ENV_PATH
+}

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

@@ -0,0 +1,2 @@
+export * from "./catalog"
+export * from "./env"

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

@@ -0,0 +1 @@
+export * from "./notes.ts";

package/packages/core/src/memory/notes.ts

@@ -0,0 +1,68 @@
+import type { Config } from "../config/loader.ts";
+import { logger } from "../utils/logger.ts";
+import { dbService } from "../storage/sqlite.ts";
+
+export interface Note {
+  title: string;
+  content: string;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export class MemoryStore {
+  private log = logger.child("memory");
+
+  constructor(config: Config) {
+    // Configuration can remain unused as sqlite db handles path resolution
+  }
+
+  write(title: string, content: string): Note {
+    const row = dbService.writeNote(title, content);
+    this.log.debug(`Wrote note: ${title}`);
+    return {
+      title: row.title,
+      content: row.content,
+      createdAt: new Date(row.createdAt),
+      updatedAt: new Date(row.updatedAt)
+    };
+  }
+
+  read(title: string): Note | null {
+    const row = dbService.readNote(title);
+    if (!row) return null;
+    return {
+      title: row.title,
+      content: row.content,
+      createdAt: new Date(row.createdAt),
+      updatedAt: new Date(row.updatedAt)
+    };
+  }
+
+  list(): Array<{ title: string; path: string }> {
+    return dbService.listNotes().map(row => ({
+      title: row.title,
+      path: `sqlite://notes/${row.id}`
+    }));
+  }
+
+  delete(title: string): boolean {
+    const deleted = dbService.deleteNote(title);
+    if (deleted) {
+      this.log.debug(`Deleted note: ${title}`);
+    }
+    return deleted;
+  }
+
+  search(query: string): Note[] {
+    return dbService.searchNotes(query).map(row => ({
+      title: row.title,
+      content: row.content,
+      createdAt: new Date(row.createdAt),
+      updatedAt: new Date(row.updatedAt)
+    }));
+  }
+}
+
+export function createMemoryStore(config: Config): MemoryStore {
+  return new MemoryStore(config);
+}

package/packages/core/src/plugins/api.ts

@@ -0,0 +1,128 @@
+import type { Logger, ChildLogger } from "../utils/logger.ts";
+import type { eventBus, EventMap, EventKey } from "../events/event-bus.ts";
+import type { StateStore } from "../state/store.ts";
+
+export interface PluginManifest {
+  name: string;
+  version: string;
+  description?: string;
+  author?: string;
+  dependencies?: string[];
+  hiveVersion?: string;
+  main?: string;
+  enabled?: boolean;
+}
+
+export interface ToolDefinition {
+  name: string;
+  description: string;
+  parameters: Record<string, ParameterDefinition>;
+  execute: (args: Record<string, unknown>) => Promise<unknown>;
+}
+
+export interface ParameterDefinition {
+  type: "string" | "number" | "boolean" | "object" | "array";
+  description?: string;
+  required?: boolean;
+  default?: unknown;
+  enum?: string[];
+  items?: ParameterDefinition;
+  properties?: Record<string, ParameterDefinition>;
+}
+
+export interface ChannelDefinition {
+  name: string;
+  type: string;
+  config: Record<string, unknown>;
+  start: () => Promise<void>;
+  stop: () => Promise<void>;
+  send: (sessionId: string, message: unknown) => Promise<void>;
+}
+
+export interface CLICommand {
+  name: string;
+  description: string;
+  handler: (args: string[], options: Record<string, unknown>) => Promise<void>;
+  options?: Record<string, CommandOption>;
+}
+
+export interface CommandOption {
+  alias?: string;
+  description?: string;
+  type?: "string" | "boolean" | "number";
+  default?: unknown;
+}
+
+export interface PluginContext {
+  pluginName: string;
+  logger: ChildLogger;
+  config: Record<string, unknown>;
+  registerTool: (tool: ToolDefinition) => void;
+  unregisterTool: (name: string) => void;
+  registerChannel: (channel: ChannelDefinition) => void;
+  unregisterChannel: (name: string) => void;
+  registerCommand: (command: CLICommand) => void;
+  unregisterCommand: (name: string) => void;
+  events: {
+    emit: <K extends EventKey>(event: K, data: EventMap[K]) => void;
+    on: <K extends EventKey>(event: K, handler: (data: EventMap[K]) => void | Promise<void>) => () => void;
+    once: <K extends EventKey>(event: K, handler: (data: EventMap[K]) => void | Promise<void>) => void;
+  };
+  state: {
+    get: () => ReturnType<StateStore["getState"]>;
+    subscribe: (listener: (state: ReturnType<StateStore["getState"]>) => void) => () => void;
+  };
+  getTool: (name: string) => ToolDefinition | undefined;
+  getTools: () => ToolDefinition[];
+}
+
+export interface InboundMessage {
+  sessionId: string;
+  channel: string;
+  userId: string;
+  content: string;
+  timestamp: number;
+}
+
+export interface AgentResponse {
+  sessionId: string;
+  content: string;
+  toolsUsed: string[];
+  duration: number;
+}
+
+export interface PluginToolCall {
+  name: string;
+  args: Record<string, unknown>;
+  sessionId: string;
+}
+
+export type MiddlewareNext = () => Promise<void>;
+export type MiddlewareResult = Promise<void>;
+
+export interface HivePlugin {
+  name: string;
+  version: string;
+  dependencies?: string[];
+  manifest?: PluginManifest;
+
+  activate(context: PluginContext): Promise<void>;
+  deactivate(): Promise<void>;
+
+  onMessage?: (message: InboundMessage, next: MiddlewareNext) => MiddlewareResult;
+  onAgentResponse?: (response: AgentResponse, next: MiddlewareNext) => MiddlewareResult;
+  onToolCall?: (call: PluginToolCall, next: () => Promise<unknown>) => Promise<unknown>;
+  onError?: (error: Error, context: Record<string, unknown>) => Promise<void>;
+}
+
+export interface PluginState {
+  name: string;
+  status: "inactive" | "activating" | "active" | "deactivating" | "error";
+  version: string;
+  enabled: boolean;
+  error?: string;
+  loadedAt?: number;
+  activatedAt?: number;
+}
+
+export type PluginConstructor = new () => HivePlugin;

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

@@ -0,0 +1,2 @@
+export * from "./api.ts";
+export * from "./loader.ts";