heyhank 0.1.0

package/server/message-bus.ts

@@ -0,0 +1,271 @@
+// ─── Inter-Agent Message Bus ─────────────────────────────────────────────────
+// Ported from AgentManager/src/messages.ts — adapted for HeyHank/Bun
+
+import { randomUUID } from "node:crypto";
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+  renameSync,
+} from "node:fs";
+import { join, dirname } from "node:path";
+import { HEYHANK_HOME } from "./paths.js";
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+export type MessageType =
+  | "task"
+  | "result"
+  | "question"
+  | "info"
+  | "status"
+  | "interrupt";
+
+export const VALID_MESSAGE_TYPES: MessageType[] = [
+  "task",
+  "result",
+  "question",
+  "info",
+  "status",
+  "interrupt",
+];
+
+export interface AgentMessage {
+  id: string;
+  from: string;
+  fromName?: string;
+  to?: string;
+  channel?: string;
+  type: MessageType;
+  content: string;
+  metadata?: Record<string, unknown>;
+  createdAt: string;
+  readBy: string[];
+}
+
+export interface MessageQuery {
+  to?: string;
+  from?: string;
+  channel?: string;
+  type?: MessageType;
+  unreadBy?: string;
+  since?: string;
+  limit?: number;
+}
+
+type MessageListener = (msg: AgentMessage) => void;
+
+// ─── Constants ───────────────────────────────────────────────────────────────
+
+const MAX_MESSAGES = 500;
+const MESSAGES_FILE = join(HEYHANK_HOME, "messages.jsonl");
+const DEBOUNCE_MS = 500;
+
+// ─── MessageBus ──────────────────────────────────────────────────────────────
+
+export class MessageBus {
+  private messages: AgentMessage[] = [];
+  private listeners = new Set<MessageListener>();
+  private persistTimer: ReturnType<typeof setTimeout> | null = null;
+  private dirty = false;
+
+  constructor() {
+    this.restore();
+  }
+
+  /** Post a new message to the bus. */
+  post(opts: {
+    from: string;
+    fromName?: string;
+    to?: string;
+    channel?: string;
+    type: MessageType;
+    content: string;
+    metadata?: Record<string, unknown>;
+  }): AgentMessage {
+    const msg: AgentMessage = {
+      id: randomUUID(),
+      from: opts.from,
+      fromName: opts.fromName,
+      to: opts.to,
+      channel: opts.channel,
+      type: opts.type,
+      content: opts.content,
+      metadata: opts.metadata,
+      createdAt: new Date().toISOString(),
+      readBy: [],
+    };
+
+    this.messages.push(msg);
+    this.trim();
+    this.schedulePersist();
+
+    // Notify listeners
+    for (const listener of this.listeners) {
+      try {
+        listener(msg);
+      } catch (err) {
+        console.error("[message-bus] Listener error:", err);
+      }
+    }
+
+    return msg;
+  }
+
+  /** Query messages with optional filters. */
+  query(opts?: MessageQuery): AgentMessage[] {
+    let result = [...this.messages];
+    if (opts?.to) {
+      result = result.filter(
+        (m) => m.to === opts.to || m.to === undefined,
+      );
+    }
+    if (opts?.from) {
+      result = result.filter((m) => m.from === opts.from);
+    }
+    if (opts?.channel) {
+      result = result.filter((m) => m.channel === opts.channel);
+    }
+    if (opts?.type) {
+      result = result.filter((m) => m.type === opts.type);
+    }
+    if (opts?.unreadBy) {
+      const agentId = opts.unreadBy;
+      result = result.filter((m) => !m.readBy.includes(agentId));
+    }
+    if (opts?.since) {
+      result = result.filter((m) => m.createdAt > opts.since!);
+    }
+    const limit = opts?.limit ?? 100;
+    return result.slice(-limit);
+  }
+
+  /** Mark a message as read by an agent. */
+  markRead(messageId: string, agentId: string): void {
+    const msg = this.messages.find((m) => m.id === messageId);
+    if (msg && !msg.readBy.includes(agentId)) {
+      msg.readBy.push(agentId);
+      this.schedulePersist();
+    }
+  }
+
+  /** Mark all messages targeted at an agent as read. */
+  markAllRead(agentId: string): void {
+    let changed = false;
+    for (const msg of this.messages) {
+      if (
+        (msg.to === agentId || msg.to === undefined) &&
+        !msg.readBy.includes(agentId)
+      ) {
+        msg.readBy.push(agentId);
+        changed = true;
+      }
+    }
+    if (changed) this.schedulePersist();
+  }
+
+  /** Get count of unread messages for an agent. */
+  unreadCount(agentId: string): number {
+    return this.messages.filter(
+      (m) =>
+        (m.to === agentId || m.to === undefined) &&
+        !m.readBy.includes(agentId),
+    ).length;
+  }
+
+  /** Delete a single message. */
+  deleteMessage(id: string): boolean {
+    const idx = this.messages.findIndex((m) => m.id === id);
+    if (idx === -1) return false;
+    this.messages.splice(idx, 1);
+    this.schedulePersist();
+    return true;
+  }
+
+  /** Clear all messages. */
+  clearAll(): void {
+    this.messages = [];
+    this.persistNow();
+  }
+
+  /** Remove all messages to/from a specific agent. */
+  cleanupForAgent(agentId: string): void {
+    const before = this.messages.length;
+    this.messages = this.messages.filter(
+      (m) => m.from !== agentId && m.to !== agentId,
+    );
+    if (this.messages.length !== before) {
+      this.schedulePersist();
+    }
+  }
+
+  /** Subscribe to new messages. Returns unsubscribe function. */
+  subscribe(listener: MessageListener): () => void {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+
+  /** Get all messages (for debugging/admin). */
+  getAll(): AgentMessage[] {
+    return [...this.messages];
+  }
+
+  // ─── Persistence ─────────────────────────────────────────────────────
+
+  private trim(): void {
+    if (this.messages.length > MAX_MESSAGES) {
+      this.messages = this.messages.slice(-MAX_MESSAGES);
+    }
+  }
+
+  private schedulePersist(): void {
+    this.dirty = true;
+    if (this.persistTimer) return;
+    this.persistTimer = setTimeout(() => {
+      this.persistTimer = null;
+      if (this.dirty) this.persistNow();
+    }, DEBOUNCE_MS);
+  }
+
+  private persistNow(): void {
+    this.dirty = false;
+    try {
+      mkdirSync(dirname(MESSAGES_FILE), { recursive: true });
+      const data = this.messages.map((m) => JSON.stringify(m)).join("\n") + "\n";
+      const tmpFile = MESSAGES_FILE + ".tmp";
+      writeFileSync(tmpFile, data, "utf-8");
+      renameSync(tmpFile, MESSAGES_FILE);
+    } catch (err) {
+      console.error("[message-bus] Failed to persist:", err);
+    }
+  }
+
+  private restore(): void {
+    try {
+      if (!existsSync(MESSAGES_FILE)) return;
+      const raw = readFileSync(MESSAGES_FILE, "utf-8");
+      const lines = raw.split("\n").filter((l) => l.trim());
+      const restored: AgentMessage[] = [];
+      for (const line of lines) {
+        try {
+          restored.push(JSON.parse(line));
+        } catch {
+          // Skip corrupt lines
+        }
+      }
+      // Keep only last MAX_MESSAGES
+      this.messages = restored.slice(-MAX_MESSAGES);
+      console.log(
+        `[message-bus] Restored ${this.messages.length} messages from disk`,
+      );
+    } catch (err) {
+      console.error("[message-bus] Failed to restore:", err);
+    }
+  }
+}
+
+/** Singleton instance */
+export const messageBus = new MessageBus();

package/server/message-delivery.ts

@@ -0,0 +1,128 @@
+// ─── Message Delivery System ─────────────────────────────────────────────────
+// Auto-delivers inter-agent messages to idle agents
+// Ported from AgentManager/src/message-delivery.ts
+
+import { messageBus } from "./message-bus.js";
+import type { AgentMessage } from "./message-bus.js";
+import type { AgentExecutor } from "./agent-executor.js";
+import type { WsBridge } from "./ws-bridge.js";
+import { isKilled } from "./kill-switch.js";
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+export interface MessageDeliveryOptions {
+  /** Delay before delivering queued messages (ms) */
+  deliverySettleMs?: number;
+}
+
+// ─── Delivery Prompt Formatting ──────────────────────────────────────────────
+
+export function formatDeliveryPrompt(
+  fromName: string,
+  fromId: string,
+  content: string,
+  type: string,
+): string {
+  if (type === "interrupt") {
+    return `[INTERRUPT from ${fromName}] ⚠️ Your current task has been interrupted. Read and act on this message immediately:
+
+<message-content>
+${content}
+</message-content>
+
+(Reply by sending a message to agent ID: ${fromId})`;
+  }
+
+  return `[Message from ${fromName} (${fromId})] Type: ${type}
+
+<message-content>
+${content}
+</message-content>
+
+Process this message and respond appropriately. To reply, send a message to agent ID: ${fromId}`;
+}
+
+// ─── Attach Auto-Delivery ────────────────────────────────────────────────────
+
+/**
+ * Subscribe to the message bus and auto-deliver messages to target agent sessions.
+ * When a message arrives for a specific agent, injects it as a user message
+ * into that agent's active session.
+ */
+export function attachMessageDelivery(
+  agentExecutor: AgentExecutor,
+  wsBridge: WsBridge,
+  opts?: MessageDeliveryOptions,
+): () => void {
+  const settleMs = opts?.deliverySettleMs ?? 2000;
+
+  const unsubscribe = messageBus.subscribe((msg: AgentMessage) => {
+    // Skip broadcasts (no specific target)
+    if (!msg.to) return;
+
+    // Skip status messages
+    if (msg.type === "status") return;
+
+    // Kill switch check
+    if (isKilled()) {
+      console.log(
+        `[message-delivery] Skipping delivery (kill switch active): ${msg.id}`,
+      );
+      return;
+    }
+
+    // Find the target agent's active session
+    const targetAgentId = msg.to;
+
+    // Delay delivery slightly to let agents settle
+    setTimeout(() => {
+      try {
+        deliverToAgent(targetAgentId, msg, wsBridge);
+      } catch (err) {
+        console.error(
+          `[message-delivery] Failed to deliver to ${targetAgentId}:`,
+          err,
+        );
+      }
+    }, settleMs);
+  });
+
+  console.log("[message-delivery] Auto-delivery attached");
+  return unsubscribe;
+}
+
+function deliverToAgent(
+  agentId: string,
+  msg: AgentMessage,
+  wsBridge: WsBridge,
+): void {
+  // Find active sessions for this agent
+  const sessions = wsBridge.getSessionMemoryStats();
+
+  // Look for a session that belongs to this agent
+  // Agent sessions are tagged with agentId in their metadata
+  for (const session of sessions) {
+    // Try to inject the message
+    const prompt = formatDeliveryPrompt(
+      msg.fromName || msg.from,
+      msg.from,
+      msg.content,
+      msg.type,
+    );
+
+    try {
+      wsBridge.injectUserMessage(session.id, prompt);
+      messageBus.markRead(msg.id, agentId);
+      console.log(
+        `[message-delivery] Delivered ${msg.type} from ${msg.from} to ${agentId} (session ${session.id.slice(0, 8)})`,
+      );
+      return;
+    } catch {
+      // Session might not accept messages, try next
+    }
+  }
+
+  console.log(
+    `[message-delivery] No active session for ${agentId}, message ${msg.id} queued`,
+  );
+}