@johpaz/hive 1.1.0

package/packages/cli/src/index.ts

@@ -0,0 +1,185 @@
+import { onboard } from "./commands/onboard";
+import { start, stop, status, reload } from "./commands/gateway";
+import { dev } from "./commands/dev";
+import { agents } from "./commands/agents";
+import { mcp } from "./commands/mcp";
+import { skills } from "./commands/skills";
+import { config } from "./commands/config";
+import { logs } from "./commands/logs";
+import { chat } from "./commands/chat";
+import { sessions } from "./commands/sessions";
+import { cron } from "./commands/cron";
+import { doctor } from "./commands/doctor";
+import { securityAudit } from "./commands/security";
+import { installService } from "./commands/service";
+import { update } from "./commands/update";
+import { message } from "./commands/message";
+import { agent } from "./commands/agent-run";
+
+const VERSION = "1.1.0";
+
+const HELP = `
+🐝 Hive — Personal Swarm AI Gateway v${VERSION}
+
+Usage: hive <command> [subcommand] [options]
+
+Commands:
+  onboard                    Wizard de configuración inicial
+  dev                        Modo desarrollo (onboard + start)
+  start [--daemon]           Arrancar el Gateway
+  stop                       Detener el Gateway
+  reload                     Recargar config sin reiniciar
+  status                     Estado del Gateway y agentes
+  chat [--agent <id>]        Chat directo en terminal
+  logs [--follow] [--level]  Ver logs del Gateway
+
+  message send --to <id> --content <text>
+                             Enviar mensaje por canal
+  agent run --message <text> Ejecutar agente con mensaje
+
+  agents add <id>            Crear nuevo agente
+  agents list [--bindings]   Listar agentes
+  agents remove <id>         Eliminar agente
+
+  mcp list                   Listar servidores MCP
+  mcp add                    Añadir servidor MCP
+  mcp test <nombre>          Verificar servidor MCP
+  mcp tools <nombre>         Listar tools de un servidor
+  mcp remove <nombre>        Eliminar servidor MCP
+
+  skills list                Listar skills instaladas
+  skills search <query>      Buscar skills
+  skills install <slug>      Instalar skill
+  skills remove <nombre>     Eliminar skill
+  skills update              Actualizar skills
+
+  config get <key>           Leer valor de config
+  config set <key> <value>   Escribir valor de config
+  config show                Mostrar config completa
+
+  sessions list              Listar sesiones
+  sessions view <id>         Ver transcripción
+  sessions prune             Eliminar sesiones inactivas
+
+  cron list                  Listar cron jobs
+  cron add                   Añadir cron job
+  cron remove <id>           Eliminar cron job
+  cron logs                  Ver logs de cron
+
+  doctor                     Diagnóstico y auto-reparación
+  security audit             Auditoría de seguridad
+  install-service            Instalar servicio systemd
+  update                     Actualizar Hive
+
+Options:
+  --help, -h                 Mostrar ayuda
+  --version, -v              Mostrar versión
+
+Examples:
+  hive onboard               Configurar Hive por primera vez
+  hive start                 Arrancar el Gateway
+  hive chat                  Chatear con el agente en terminal
+  hive message send --to 123 --content "Hola"
+  hive agent run --message "Analiza README.md" --wait
+  hive agents add work       Crear agente "work"
+  hive mcp add               Añadir servidor MCP
+  hive doctor                Diagnosticar problemas
+
+Documentation:
+  English: https://github.com/johpaz/hive/docs
+  Español: https://github.com/johpaz/hive/docs/es
+`;
+
+async function main(): Promise<void> {
+  const args = process.argv.slice(2);
+  const command = args[0];
+  const subcommand = args[1];
+  const flags = args.filter((a) => a.startsWith("--"));
+
+  switch (command) {
+    case "onboard":
+      await onboard();
+      break;
+    case "dev":
+      await dev();
+      break;
+    case "start":
+      await start(flags);
+      break;
+    case "stop":
+      await stop();
+      break;
+    case "reload":
+      await reload();
+      break;
+    case "status":
+      await status(flags);
+      break;
+    case "chat":
+      await chat(flags);
+      break;
+    case "logs":
+      await logs(flags);
+      break;
+    case "message":
+      await message(subcommand, args.slice(2));
+      break;
+    case "agent":
+      await agent(subcommand, args.slice(2));
+      break;
+    case "agents":
+      await agents(subcommand, args.slice(2));
+      break;
+    case "mcp":
+      await mcp(subcommand, args.slice(2));
+      break;
+    case "skills":
+      await skills(subcommand, args.slice(2));
+      break;
+    case "config":
+      await config(subcommand, args.slice(2));
+      break;
+    case "sessions":
+      await sessions(subcommand, args.slice(2));
+      break;
+    case "cron":
+      await cron(subcommand, args.slice(2));
+      break;
+    case "doctor":
+      await doctor();
+      break;
+    case "security":
+      if (subcommand === "audit") {
+        await securityAudit();
+      } else {
+        console.log("Usage: hive security audit");
+      }
+      break;
+    case "install-service":
+      await installService();
+      break;
+    case "update":
+      await update();
+      break;
+    case "--version":
+    case "-v":
+    case "version":
+      console.log(`Hive v${VERSION}`);
+      break;
+    case "--help":
+    case "-h":
+    case "help":
+    case undefined:
+      console.log(HELP);
+      break;
+    default:
+      console.error(`❌ Comando desconocido: "${command}"\n`);
+      console.log(HELP);
+      process.exit(1);
+  }
+}
+
+main().catch((error) => {
+  console.error("Fatal error:", error.message);
+  process.exit(1);
+});

package/packages/cli/src/utils/token.ts

@@ -0,0 +1,6 @@
+import { randomBytes } from "node:crypto"
+
+export function generateAuthToken(): string {
+    // 32 bytes → 43 caracteres base64url seguros
+    return randomBytes(32).toString("base64url")
+}

package/packages/code-bridge/README.md

@@ -0,0 +1,78 @@
+# @johpaz/hive-code-bridge
+
+Code Bridge for the Hive ecosystem. Exposes a **local WebSocket mesh** (via `Bun.serve`) that spawns and supervises CLI AI tools (e.g. `opencode`, `gemini`, `qwen`) as child processes, streaming their output and telemetry to any connected dashboard client.
+
+## Architecture
+
+```
+Dashboard (Angular) ──WS──► @johpaz/hive-code-bridge ──Bun.spawn──► CLI tool (opencode / gemini / qwen…)
+                                                    ◄──WS──── telemetry events (stdout chunks, progress, tokens)
+```
+
+## Files
+
+| File | Purpose |
+|---|---|
+| `src/index.ts` | Bun.serve entry point — HTTP health + WebSocket handler |
+| `src/schemas.ts` | Zod schemas: `AgentRole`, `SubagentConfig`, `TelemetryEvent`, `DashboardCommand` |
+| `src/process-manager.ts` | Spawns/kills processes, streams stdout/stderr, parses `HIVE_PROGRESS` and `HIVE_TOKENS` hints |
+
+## Running
+
+```bash
+# From the monorepo root:
+bun run packages/code-bridge/src/index.ts
+
+# Or from this package:
+bun run src/index.ts
+```
+
+Server starts on `ws://localhost:18791` by default (`CODE_BRIDGE_PORT` env override).
+
+## WebSocket Protocol
+
+### Dashboard → Code Bridge
+
+```jsonc
+// Launch a CLI subagent
+{ "cmd": "launch", "taskId": "uuid", "prompt": "Refactor auth module", "config": { "role": "development", "cli": "opencode" } }
+
+// Cancel a running agent
+{ "cmd": "cancel", "taskId": "uuid" }
+
+// Request current status snapshot
+{ "cmd": "status" }
+```
+
+### Code Bridge → Dashboard (broadcast)
+
+| Event type | Description |
+|---|---|
+| `code-bridge:status` | Full snapshot of all agents (sent on connect and on `status` command) |
+| `agent:started` | Process PID and CLI tool |
+| `agent:output` | stdout/stderr chunk |
+| `agent:progress` | 0–100 percent (from `HIVE_PROGRESS:<n>` in stdout) |
+| `agent:token_usage` | Token counters + model (from `HIVE_TOKENS:input=<n>,output=<n>,model=<name>`) |
+| `agent:finished` | Exit code |
+| `agent:cancelled` | Cancelled by dashboard |
+| `agent:error` | Non-zero exit or spawn error |
+
+## HIVE Protocol Hints
+
+CLI tools can emit structured hints in their stdout to feed the dashboard:
+
+```
+HIVE_PROGRESS:42
+HIVE_TOKENS:input=1200,output=350,model=gemini-2.0-flash
+```
+
+## Tests
+
+```bash
+bun test src/schemas.test.ts
+bun test src/process-manager.test.ts
+# or all at once:
+bun test
+```
+
+Tests cover: schema validation, launch/cancel lifecycle, stdout streaming, progress/token hint parsing.

package/packages/code-bridge/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@johpaz/hive-code-bridge",
+  "version": "1.1.0",
+  "private": true,
+  "description": "Code Bridge - Bridge between CLI tools and Dashboard via WebSocket",
+  "type": "module",
+  "main": "src/index.ts",
+  "scripts": {
+    "dev": "bun run src/index.ts"
+  },
+  "dependencies": {
+    "@johpaz/hive-mcp": "^1.1.0",
+    "zod": "^4.3.6"
+  },
+  "peerDependencies": {
+    "@johpaz/hive-core": "^1.1.0"
+  }
+}

package/packages/code-bridge/src/index.ts

@@ -0,0 +1,95 @@
+import { ProcessManager } from "./process-manager.ts";
+import { DashboardCommand } from "./schemas.ts";
+
+const CODE_BRIDGE_PORT = parseInt(process.env.CODE_BRIDGE_PORT ?? "18791", 10);
+
+const manager = new ProcessManager();
+
+const server = Bun.serve<{ id: string }>({
+    port: CODE_BRIDGE_PORT,
+
+    // ── HTTP routes ──────────────────────────────────────────────────────────
+    fetch(req, server) {
+        const url = new URL(req.url);
+
+        // Upgrade WebSocket connections
+        if (url.pathname === "/ws") {
+            const id = crypto.randomUUID();
+            const upgraded = server.upgrade(req, { data: { id } });
+            if (upgraded) return undefined;
+            return new Response("WebSocket upgrade failed", { status: 400 });
+        }
+
+        // Simple REST ping
+        if (url.pathname === "/health") {
+            return new Response(JSON.stringify({ ok: true, port: CODE_BRIDGE_PORT }), {
+                headers: { "Content-Type": "application/json" },
+            });
+        }
+
+        // Status snapshot (REST fallback for the dashboard initial load)
+        if (url.pathname === "/status") {
+            return new Response(JSON.stringify(manager.status()), {
+                headers: { "Content-Type": "application/json" },
+            });
+        }
+
+        return new Response("Not found", { status: 404 });
+    },
+
+    // ── WebSocket handlers ───────────────────────────────────────────────────
+    websocket: {
+        open(ws) {
+            manager.subscribe(ws);
+            // Immediately send the current snapshot to the newly connected client
+            ws.send(JSON.stringify(manager.status()));
+        },
+
+        async message(ws, raw) {
+            let parsed: unknown;
+            try {
+                parsed = JSON.parse(typeof raw === "string" ? raw : new TextDecoder().decode(raw));
+            } catch {
+                ws.send(JSON.stringify({ type: "error", message: "Invalid JSON" }));
+                return;
+            }
+
+            const cmd = DashboardCommand.safeParse(parsed);
+            if (!cmd.success) {
+                ws.send(JSON.stringify({ type: "error", message: cmd.error.message }));
+                return;
+            }
+
+            const command = cmd.data;
+
+            switch (command.cmd) {
+                case "launch": {
+                    try {
+                        const pid = await manager.launch(command.taskId, command.config, command.prompt);
+                        ws.send(JSON.stringify({ type: "ack", cmd: "launch", taskId: command.taskId, pid }));
+                    } catch (err: any) {
+                        ws.send(JSON.stringify({ type: "error", message: err.message }));
+                    }
+                    break;
+                }
+
+                case "cancel": {
+                    const ok = manager.cancel(command.taskId);
+                    ws.send(JSON.stringify({ type: "ack", cmd: "cancel", taskId: command.taskId, ok }));
+                    break;
+                }
+
+                case "status": {
+                    ws.send(JSON.stringify(manager.status()));
+                    break;
+                }
+            }
+        },
+
+        close(ws) {
+            manager.unsubscribe(ws);
+        },
+    },
+});
+
+console.log(`🌉 Hive Code Bridge running on ws://localhost:${server.port}`);

package/packages/code-bridge/src/process-manager.ts

@@ -0,0 +1,212 @@
+import type { ServerWebSocket } from "bun";
+import type { SubagentConfig, TelemetryEvent } from "./schemas.ts";
+import { AgentRole } from "./schemas.ts";
+
+/** Live record of a running subagent process */
+interface AgentRecord {
+    taskId: string;
+    config: SubagentConfig;
+    pid: number;
+    proc: ReturnType<typeof Bun.spawn>;
+    state: "running" | "finished" | "cancelled" | "error";
+    progress: number;
+    tokens: { input: number; output: number };
+    model?: string;
+    startedAt: number;
+}
+
+type WsData = { id: string };
+
+export class ProcessManager {
+    private agents = new Map<string, AgentRecord>();
+    private sockets = new Set<ServerWebSocket<WsData>>();
+
+    // ── Socket subscription ──────────────────────────────────────────────────
+
+    subscribe(ws: ServerWebSocket<WsData>) {
+        this.sockets.add(ws);
+    }
+
+    unsubscribe(ws: ServerWebSocket<WsData>) {
+        this.sockets.delete(ws);
+    }
+
+    private broadcast(event: TelemetryEvent) {
+        const payload = JSON.stringify(event);
+        for (const ws of this.sockets) {
+            try {
+                ws.send(payload);
+            } catch {
+                this.sockets.delete(ws);
+            }
+        }
+    }
+
+    // ── Launch ───────────────────────────────────────────────────────────────
+
+    async launch(taskId: string, config: SubagentConfig, prompt: string) {
+        if (this.agents.has(taskId)) {
+            throw new Error(`Task ${taskId} is already running`);
+        }
+
+        const args = [config.cli, ...config.args];
+        const proc = Bun.spawn(args, {
+            cwd: config.cwd ?? process.cwd(),
+            stdin: "pipe",
+            stdout: "pipe",
+            stderr: "pipe",
+            env: { ...process.env, HIVE_ROLE: config.role },
+        });
+
+        const record: AgentRecord = {
+            taskId,
+            config,
+            pid: proc.pid,
+            proc,
+            state: "running",
+            progress: 0,
+            tokens: { input: 0, output: 0 },
+            startedAt: Date.now(),
+        };
+
+        this.agents.set(taskId, record);
+
+        this.broadcast({
+            type: "agent:started",
+            ts: Date.now(),
+            role: config.role,
+            pid: proc.pid,
+            cli: config.cli,
+            taskId,
+        });
+
+        // Write the prompt to stdin then close it
+        proc.stdin.write(prompt);
+        proc.stdin.end();
+
+        // Stream stdout
+        this.pipeStream(record, proc.stdout, "stdout");
+        // Stream stderr
+        this.pipeStream(record, proc.stderr, "stderr");
+
+        // Wait for process exit
+        proc.exited.then((exitCode) => {
+            const r = this.agents.get(taskId);
+            if (!r || r.state === "cancelled") return;
+            r.state = exitCode === 0 ? "finished" : "error";
+            if (exitCode === 0) {
+                this.broadcast({
+                    type: "agent:finished",
+                    ts: Date.now(),
+                    role: config.role,
+                    taskId,
+                    exitCode,
+                });
+            } else {
+                this.broadcast({
+                    type: "agent:error",
+                    ts: Date.now(),
+                    role: config.role,
+                    taskId,
+                    message: `Process exited with code ${exitCode}`,
+                });
+            }
+        });
+
+        return record.pid;
+    }
+
+    // ── Cancel ───────────────────────────────────────────────────────────────
+
+    cancel(taskId: string) {
+        const record = this.agents.get(taskId);
+        if (!record) return false;
+        record.state = "cancelled";
+        record.proc.kill();
+        this.broadcast({
+            type: "agent:cancelled",
+            ts: Date.now(),
+            role: record.config.role,
+            taskId,
+        });
+        return true;
+    }
+
+    // ── Status snapshot ──────────────────────────────────────────────────────
+
+    status(): TelemetryEvent {
+        return {
+            type: "code-bridge:status",
+            ts: Date.now(),
+            agents: [...this.agents.values()].map((r) => ({
+                taskId: r.taskId,
+                role: r.config.role,
+                cli: r.config.cli,
+                pid: r.pid,
+                state: r.state,
+                progress: r.progress,
+                tokens: r.tokens,
+                model: r.model,
+            })),
+        };
+    }
+
+    // ── Helpers ──────────────────────────────────────────────────────────────
+
+    private async pipeStream(
+        record: AgentRecord,
+        stream: ReadableStream<Uint8Array>,
+        kind: "stdout" | "stderr"
+    ) {
+        const reader = stream.getReader();
+        const decoder = new TextDecoder();
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done) break;
+                const chunk = decoder.decode(value);
+
+                // Parse progress hints: lines containing "HIVE_PROGRESS:<n>"
+                for (const line of chunk.split("\n")) {
+                    const m = line.match(/HIVE_PROGRESS:(\d+)/);
+                    if (m) {
+                        record.progress = Math.min(100, parseInt(m[1], 10));
+                        this.broadcast({
+                            type: "agent:progress",
+                            ts: Date.now(),
+                            role: record.config.role,
+                            taskId: record.taskId,
+                            percent: record.progress,
+                        });
+                    }
+                    // Parse token hints: "HIVE_TOKENS:input=<n>,output=<n>,model=<name>"
+                    const t = line.match(/HIVE_TOKENS:input=(\d+),output=(\d+)(?:,model=(.+))?/);
+                    if (t) {
+                        record.tokens = { input: parseInt(t[1], 10), output: parseInt(t[2], 10) };
+                        if (t[3]) record.model = t[3].trim();
+                        this.broadcast({
+                            type: "agent:token_usage",
+                            ts: Date.now(),
+                            role: record.config.role,
+                            taskId: record.taskId,
+                            inputTokens: record.tokens.input,
+                            outputTokens: record.tokens.output,
+                            model: record.model ?? "unknown",
+                        });
+                    }
+                }
+
+                this.broadcast({
+                    type: "agent:output",
+                    ts: Date.now(),
+                    role: record.config.role,
+                    taskId: record.taskId,
+                    stream: kind,
+                    chunk,
+                });
+            }
+        } catch {
+            // stream closed
+        }
+    }
+}