@sleep2agi/commhub-server 0.8.5 → 0.8.6-preview.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sleep2agi/commhub-server",
-  "version": "0.8.5",
+  "version": "0.8.6-preview.1",
   "description": "CommHub Server — AI Agent communication hub with MCP protocol, multi-network isolation, user auth, and 17 MCP tools.",
   "type": "module",
   "main": "src/index.ts",
@@ -46,6 +46,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.0",
-    "bun-types": "^1.3.13"
+    "bun-types": "^1.3.13",
+    "hono": "^4.12.25"
   }
 }

package/src/auth_login_guard.test.ts

@@ -0,0 +1,130 @@
+import { describe, expect, test } from "bun:test";
+import {
+  LOGIN_FAILURE_THRESHOLD,
+  LOGIN_LOCK_BASE_MS,
+  LOGIN_LOCK_MAX_MS,
+  LOGIN_IP_MAX_PER_WINDOW,
+  LOGIN_IP_WINDOW_MS,
+  getLoginClientIp,
+  LoginFailureLockout,
+  LoginIpRateLimiter,
+  normalizeLoginUsername,
+} from "./auth_login_guard";
+
+describe("LoginIpRateLimiter", () => {
+  test("allows the first N attempts and blocks N+1 within the window", () => {
+    const lim = new LoginIpRateLimiter(60_000, 3);
+    expect(lim.check("203.0.113.10", 1000).allowed).toBe(true);
+    expect(lim.check("203.0.113.10", 1001).allowed).toBe(true);
+    expect(lim.check("203.0.113.10", 1002).allowed).toBe(true);
+    const blocked = lim.check("203.0.113.10", 1003);
+    expect(blocked.allowed).toBe(false);
+    expect(blocked.retryAfterMs).toBeGreaterThan(0);
+  });
+
+  test("default public IP limit is 10/min", () => {
+    expect(LOGIN_IP_WINDOW_MS).toBe(60_000);
+    expect(LOGIN_IP_MAX_PER_WINDOW).toBe(10);
+  });
+
+  test("evicts expired entries before enforcing the cap", () => {
+    const lim = new LoginIpRateLimiter(100, 10, 2);
+    expect(lim.check("192.0.2.1", 0).allowed).toBe(true);
+    expect(lim.check("192.0.2.2", 0).allowed).toBe(true);
+    expect(lim.check("192.0.2.3", 101).allowed).toBe(true);
+
+    expect(lim.check("192.0.2.1", 102).remaining).toBe(9);
+  });
+
+  test("evicts the oldest active entry when the cap is full", () => {
+    const lim = new LoginIpRateLimiter(60_000, 1, 2);
+    expect(lim.check("192.0.2.1", 0).allowed).toBe(true);
+    expect(lim.check("192.0.2.2", 1).allowed).toBe(true);
+    expect(lim.check("192.0.2.3", 2).allowed).toBe(true);
+
+    expect(lim.check("192.0.2.1", 3).allowed).toBe(true);
+  });
+});
+
+describe("LoginFailureLockout", () => {
+  test("locks on the fifth failure and doubles subsequent lock durations", () => {
+    const lockout = new LoginFailureLockout(5, 30_000, 900_000);
+    const t0 = 1_700_000_000_000;
+    for (let i = 0; i < 4; i++) {
+      const r = lockout.recordFailure("Alice", t0 + i);
+      expect(r.locked).toBe(false);
+      expect(r.failures).toBe(i + 1);
+    }
+
+    const first = lockout.recordFailure(" alice ", t0 + 5);
+    expect(first.locked).toBe(true);
+    expect(first.lockMs).toBe(30_000);
+    expect(lockout.check("ALICE", t0 + 6).locked).toBe(true);
+
+    const second = lockout.recordFailure("alice", t0 + 30_006);
+    expect(second.locked).toBe(true);
+    expect(second.lockMs).toBe(60_000);
+  });
+
+  test("caps exponential lock duration and success clears failure state", () => {
+    const lockout = new LoginFailureLockout(2, 1000, 4000);
+    const t0 = 10_000;
+    expect(lockout.recordFailure("bob", t0).locked).toBe(false);
+    expect(lockout.recordFailure("bob", t0 + 1).lockMs).toBe(1000);
+    expect(lockout.recordFailure("bob", t0 + 1001).lockMs).toBe(2000);
+    expect(lockout.recordFailure("bob", t0 + 3002).lockMs).toBe(4000);
+    expect(lockout.recordFailure("bob", t0 + 7003).lockMs).toBe(4000);
+
+    lockout.recordSuccess("bob");
+    expect(lockout.check("bob", t0 + 7004).locked).toBe(false);
+    expect(lockout.recordFailure("bob", t0 + 7005).locked).toBe(false);
+  });
+
+  test("default failure policy is 5 failures, 30s base, 15min cap", () => {
+    expect(LOGIN_FAILURE_THRESHOLD).toBe(5);
+    expect(LOGIN_LOCK_BASE_MS).toBe(30_000);
+    expect(LOGIN_LOCK_MAX_MS).toBe(15 * 60_000);
+  });
+
+  test("evicts expired failure entries before enforcing the cap", () => {
+    const lockout = new LoginFailureLockout(2, 100, 1000, 2);
+    expect(lockout.recordFailure("alice", 0).locked).toBe(false);
+    expect(lockout.recordFailure("bob", 0).locked).toBe(false);
+    expect(lockout.recordFailure("carol", 1).locked).toBe(false);
+
+    expect(lockout.recordFailure("alice", 2).locked).toBe(false);
+  });
+
+  test("evicts the oldest active failure entry when the cap is full", () => {
+    const lockout = new LoginFailureLockout(2, 1000, 1000, 2);
+    expect(lockout.recordFailure("alice", 0).locked).toBe(false);
+    expect(lockout.recordFailure("bob", 1).locked).toBe(false);
+    expect(lockout.recordFailure("carol", 2).locked).toBe(false);
+
+    expect(lockout.recordFailure("alice", 3).locked).toBe(false);
+  });
+});
+
+describe("normalizeLoginUsername", () => {
+  test("normalizes for case-insensitive lockout keys", () => {
+    expect(normalizeLoginUsername(" Alice ")).toBe("alice");
+    expect(normalizeLoginUsername(undefined)).toBe("");
+  });
+});
+
+describe("getLoginClientIp", () => {
+  test("uses the last x-forwarded-for hop so spoofed first hops do not bypass login rate limits", () => {
+    const req = new Request("http://127.0.0.1/api/auth/login", {
+      headers: { "x-forwarded-for": "198.51.100.99, 203.0.113.10" },
+    });
+    expect(getLoginClientIp(req)).toBe("203.0.113.10");
+  });
+
+  test("falls back to x-real-ip, then unknown", () => {
+    const withRealIp = new Request("http://127.0.0.1/api/auth/login", {
+      headers: { "x-real-ip": "203.0.113.20" },
+    });
+    expect(getLoginClientIp(withRealIp)).toBe("203.0.113.20");
+    expect(getLoginClientIp(new Request("http://127.0.0.1/api/auth/login"))).toBe("unknown");
+  });
+});

package/src/auth_login_guard.ts

@@ -0,0 +1,142 @@
+// #226 — public login brute-force guard.
+// In-memory by design: zero dependency, process-local defence-in-depth for the
+// public /api/auth/login surface. Bearer token auth paths do not use this file.
+
+export const LOGIN_IP_WINDOW_MS = 60_000;
+export const LOGIN_IP_MAX_PER_WINDOW = 10;
+export const LOGIN_FAILURE_THRESHOLD = 5;
+export const LOGIN_LOCK_BASE_MS = 30_000;
+export const LOGIN_LOCK_MAX_MS = 15 * 60_000;
+export const LOGIN_GUARD_MAX_ENTRIES = 50_000;
+
+type WindowState = { count: number; resetAt: number };
+
+export class LoginIpRateLimiter {
+  private state = new Map<string, WindowState>();
+
+  constructor(
+    private readonly windowMs: number = LOGIN_IP_WINDOW_MS,
+    private readonly maxPerWindow: number = LOGIN_IP_MAX_PER_WINDOW,
+    private readonly maxEntries: number = LOGIN_GUARD_MAX_ENTRIES,
+  ) {}
+
+  check(key: string, nowMs: number = Date.now()): { allowed: boolean; remaining: number; resetAt: number; retryAfterMs?: number } {
+    if (this.state.size >= this.maxEntries && !this.state.has(key)) {
+      pruneExpired(this.state, nowMs, (entry) => nowMs >= entry.resetAt);
+      evictOldestUntilBelowCap(this.state, this.maxEntries);
+    }
+    const entry = this.state.get(key);
+    if (!entry || nowMs >= entry.resetAt) {
+      const resetAt = nowMs + this.windowMs;
+      this.state.set(key, { count: 1, resetAt });
+      return { allowed: true, remaining: this.maxPerWindow - 1, resetAt };
+    }
+    if (entry.count >= this.maxPerWindow) {
+      return { allowed: false, remaining: 0, resetAt: entry.resetAt, retryAfterMs: entry.resetAt - nowMs };
+    }
+    entry.count++;
+    return { allowed: true, remaining: this.maxPerWindow - entry.count, resetAt: entry.resetAt };
+  }
+
+  reset(): void {
+    this.state.clear();
+  }
+}
+
+type FailureState = { failures: number; lockedUntil: number };
+
+export class LoginFailureLockout {
+  private state = new Map<string, FailureState>();
+
+  constructor(
+    private readonly threshold: number = LOGIN_FAILURE_THRESHOLD,
+    private readonly baseLockMs: number = LOGIN_LOCK_BASE_MS,
+    private readonly maxLockMs: number = LOGIN_LOCK_MAX_MS,
+    private readonly maxEntries: number = LOGIN_GUARD_MAX_ENTRIES,
+  ) {}
+
+  check(username: string, nowMs: number = Date.now()): { locked: boolean; retryAfterMs?: number; lockedUntil?: number } {
+    const key = normalizeLoginUsername(username);
+    if (!key) return { locked: false };
+    const entry = this.state.get(key);
+    if (!entry || !entry.lockedUntil || nowMs >= entry.lockedUntil) return { locked: false };
+    return { locked: true, retryAfterMs: entry.lockedUntil - nowMs, lockedUntil: entry.lockedUntil };
+  }
+
+  recordFailure(username: string, nowMs: number = Date.now()): { locked: boolean; failures: number; lockMs?: number; lockedUntil?: number } {
+    const key = normalizeLoginUsername(username);
+    if (!key) return { locked: false, failures: 0 };
+    if (this.state.size >= this.maxEntries && !this.state.has(key)) {
+      pruneExpired(this.state, nowMs, (entry) => !entry.lockedUntil || nowMs >= entry.lockedUntil);
+      evictOldestUntilBelowCap(this.state, this.maxEntries);
+    }
+    const current = this.state.get(key);
+    const failures = (current?.failures ?? 0) + 1;
+    if (failures < this.threshold) {
+      this.state.set(key, { failures, lockedUntil: 0 });
+      return { locked: false, failures };
+    }
+
+    const exponent = failures - this.threshold;
+    const lockMs = Math.min(this.baseLockMs * Math.pow(2, exponent), this.maxLockMs);
+    const lockedUntil = nowMs + lockMs;
+    this.state.set(key, { failures, lockedUntil });
+    return { locked: true, failures, lockMs, lockedUntil };
+  }
+
+  recordSuccess(username: string): void {
+    const key = normalizeLoginUsername(username);
+    if (key) this.state.delete(key);
+  }
+
+  reset(): void {
+    this.state.clear();
+  }
+}
+
+export function normalizeLoginUsername(username: unknown): string {
+  return typeof username === "string" ? username.trim().toLowerCase() : "";
+}
+
+export function getLoginClientIp(req: Request): string {
+  const fwd = req.headers.get("x-forwarded-for");
+  if (fwd) {
+    const last = fwd.split(",").map((s) => s.trim()).filter(Boolean).at(-1);
+    if (last) return last;
+  }
+  return req.headers.get("x-real-ip")?.trim() || "unknown";
+}
+
+function pruneExpired<T>(map: Map<string, T>, nowMs: number, expired: (entry: T, nowMs: number) => boolean): void {
+  for (const [key, entry] of map) {
+    if (expired(entry, nowMs)) map.delete(key);
+  }
+}
+
+function evictOldestUntilBelowCap<T>(map: Map<string, T>, maxEntries: number): void {
+  while (map.size >= maxEntries) {
+    const oldest = map.keys().next().value as string | undefined;
+    if (!oldest) return;
+    map.delete(oldest);
+  }
+}
+
+function envInt(name: string, fallback: number): number {
+  const raw = process.env[name];
+  if (!raw) return fallback;
+  const n = Number(raw);
+  return Number.isFinite(n) && n > 0 ? n : fallback;
+}
+
+export const sharedLoginIpRateLimiter = new LoginIpRateLimiter(
+  envInt("COMMHUB_LOGIN_IP_WINDOW_MS", LOGIN_IP_WINDOW_MS),
+  envInt("COMMHUB_LOGIN_IP_MAX", LOGIN_IP_MAX_PER_WINDOW),
+  envInt("COMMHUB_LOGIN_GUARD_MAX_ENTRIES", LOGIN_GUARD_MAX_ENTRIES),
+);
+
+export const sharedLoginFailureLockout = new LoginFailureLockout(
+  envInt("COMMHUB_LOGIN_FAILURE_THRESHOLD", LOGIN_FAILURE_THRESHOLD),
+  envInt("COMMHUB_LOGIN_LOCK_BASE_MS", LOGIN_LOCK_BASE_MS),
+  envInt("COMMHUB_LOGIN_LOCK_MAX_MS", LOGIN_LOCK_MAX_MS),
+  envInt("COMMHUB_LOGIN_GUARD_MAX_ENTRIES", LOGIN_GUARD_MAX_ENTRIES),
+);

package/src/db.ts

@@ -123,13 +123,14 @@ db.exec(`
     ON agent_telemetry(network_id, alias, created_at);
 `);
 
-// inbox: add in_reply_to, requires_response, expires_at, scope
+// inbox: add in_reply_to, requires_response, expires_at, scope, node identity
 for (const col of [
   { name: "in_reply_to", def: "TEXT" },
   { name: "requires_response", def: "TEXT DEFAULT 'reply'" },
   { name: "expires_at", def: "TEXT" },
   { name: "scope", def: "TEXT DEFAULT 'single'" },
   { name: "meta_json", def: "TEXT" },
+  { name: "node_id", def: "TEXT" },
 ]) {
   try { db.exec(`ALTER TABLE inbox ADD COLUMN ${col.name} ${col.def}`); } catch {}
 }
@@ -138,6 +139,7 @@ for (const col of [
 try { db.exec("CREATE INDEX IF NOT EXISTS idx_inbox_type ON inbox(type)"); } catch {}
 try { db.exec("CREATE INDEX IF NOT EXISTS idx_inbox_from ON inbox(from_session)"); } catch {}
 try { db.exec("CREATE INDEX IF NOT EXISTS idx_inbox_reply ON inbox(in_reply_to)"); } catch {}
+try { db.exec("CREATE INDEX IF NOT EXISTS idx_inbox_node ON inbox(node_id)"); } catch {}
 try { db.exec("CREATE INDEX IF NOT EXISTS idx_sessions_node ON sessions(node_id)"); } catch {}
 
 // tasks table (V2)
@@ -384,6 +386,185 @@ for (const table of ["sessions", "nodes", "tasks", "inbox", "task_events", "comp
   try { db.exec(`ALTER TABLE ${table} ADD COLUMN network_id TEXT`); } catch {}
 }
 
+// PR-1 (#146): durable node identity on historical inbox/tasks rows. Some
+// existing databases created `tasks` before from_node_id/to_node_id were in the
+// CREATE TABLE statement, so keep these ALTERs explicit and idempotent.
+for (const col of [
+  { table: "tasks", name: "from_node_id", def: "TEXT" },
+  { table: "tasks", name: "to_node_id", def: "TEXT" },
+  { table: "inbox", name: "node_id", def: "TEXT" },
+]) {
+  try { db.exec(`ALTER TABLE ${col.table} ADD COLUMN ${col.name} ${col.def}`); } catch {}
+}
+
+try { db.exec("CREATE INDEX IF NOT EXISTS idx_tasks_from_node ON tasks(from_node_id)"); } catch {}
+try { db.exec("CREATE INDEX IF NOT EXISTS idx_tasks_to_node ON tasks(to_node_id)"); } catch {}
+try { db.exec("CREATE INDEX IF NOT EXISTS idx_inbox_node ON inbox(node_id)"); } catch {}
+
+function backfillMessageNodeIds() {
+  let inboxDirect = 0;
+  let inboxRenamed = 0;
+  let tasksToDirect = 0;
+  let tasksToRenamed = 0;
+  let tasksFromDirect = 0;
+  let tasksFromRenamed = 0;
+
+  try {
+    inboxDirect = db.run(`
+      UPDATE inbox
+      SET node_id = (
+        SELECT s.node_id FROM sessions s
+        WHERE s.node_id IS NOT NULL
+          AND s.alias = inbox.session_name
+          AND COALESCE(s.network_id, 'default') = COALESCE(inbox.network_id, 'default')
+        ORDER BY s.updated_at DESC
+        LIMIT 1
+      )
+      WHERE node_id IS NULL
+        AND EXISTS (
+          SELECT 1 FROM sessions s
+          WHERE s.node_id IS NOT NULL
+            AND s.alias = inbox.session_name
+            AND COALESCE(s.network_id, 'default') = COALESCE(inbox.network_id, 'default')
+        )
+    `).changes;
+  } catch {}
+
+  try {
+    inboxRenamed = db.run(`
+      UPDATE inbox
+      SET node_id = (
+        SELECT s.node_id FROM rename_txn r
+        JOIN sessions s
+          ON s.alias = r.new_alias
+         AND COALESCE(s.network_id, 'default') = COALESCE(r.network_id, 'default')
+        WHERE s.node_id IS NOT NULL
+          AND r.status = 'committed'
+          AND r.old_alias = inbox.session_name
+          AND COALESCE(r.network_id, 'default') = COALESCE(inbox.network_id, 'default')
+        ORDER BY r.committed_at DESC
+        LIMIT 1
+      )
+      WHERE node_id IS NULL
+        AND EXISTS (
+          SELECT 1 FROM rename_txn r
+          JOIN sessions s
+            ON s.alias = r.new_alias
+           AND COALESCE(s.network_id, 'default') = COALESCE(r.network_id, 'default')
+          WHERE s.node_id IS NOT NULL
+            AND r.status = 'committed'
+            AND r.old_alias = inbox.session_name
+            AND COALESCE(r.network_id, 'default') = COALESCE(inbox.network_id, 'default')
+        )
+    `).changes;
+  } catch {}
+
+  try {
+    tasksToDirect = db.run(`
+      UPDATE tasks
+      SET to_node_id = (
+        SELECT s.node_id FROM sessions s
+        WHERE s.node_id IS NOT NULL
+          AND s.alias = tasks.to_name
+          AND COALESCE(s.network_id, 'default') = COALESCE(tasks.network_id, 'default')
+        ORDER BY s.updated_at DESC
+        LIMIT 1
+      )
+      WHERE to_node_id IS NULL
+        AND EXISTS (
+          SELECT 1 FROM sessions s
+          WHERE s.node_id IS NOT NULL
+            AND s.alias = tasks.to_name
+            AND COALESCE(s.network_id, 'default') = COALESCE(tasks.network_id, 'default')
+        )
+    `).changes;
+  } catch {}
+
+  try {
+    tasksToRenamed = db.run(`
+      UPDATE tasks
+      SET to_node_id = (
+        SELECT s.node_id FROM rename_txn r
+        JOIN sessions s
+          ON s.alias = r.new_alias
+         AND COALESCE(s.network_id, 'default') = COALESCE(r.network_id, 'default')
+        WHERE s.node_id IS NOT NULL
+          AND r.status = 'committed'
+          AND r.old_alias = tasks.to_name
+          AND COALESCE(r.network_id, 'default') = COALESCE(tasks.network_id, 'default')
+        ORDER BY r.committed_at DESC
+        LIMIT 1
+      )
+      WHERE to_node_id IS NULL
+        AND EXISTS (
+          SELECT 1 FROM rename_txn r
+          JOIN sessions s
+            ON s.alias = r.new_alias
+           AND COALESCE(s.network_id, 'default') = COALESCE(r.network_id, 'default')
+          WHERE s.node_id IS NOT NULL
+            AND r.status = 'committed'
+            AND r.old_alias = tasks.to_name
+            AND COALESCE(r.network_id, 'default') = COALESCE(tasks.network_id, 'default')
+        )
+    `).changes;
+  } catch {}
+
+  try {
+    tasksFromDirect = db.run(`
+      UPDATE tasks
+      SET from_node_id = (
+        SELECT s.node_id FROM sessions s
+        WHERE s.node_id IS NOT NULL
+          AND s.alias = tasks.from_name
+          AND COALESCE(s.network_id, 'default') = COALESCE(tasks.network_id, 'default')
+        ORDER BY s.updated_at DESC
+        LIMIT 1
+      )
+      WHERE from_node_id IS NULL
+        AND EXISTS (
+          SELECT 1 FROM sessions s
+          WHERE s.node_id IS NOT NULL
+            AND s.alias = tasks.from_name
+            AND COALESCE(s.network_id, 'default') = COALESCE(tasks.network_id, 'default')
+        )
+    `).changes;
+  } catch {}
+
+  try {
+    tasksFromRenamed = db.run(`
+      UPDATE tasks
+      SET from_node_id = (
+        SELECT s.node_id FROM rename_txn r
+        JOIN sessions s
+          ON s.alias = r.new_alias
+         AND COALESCE(s.network_id, 'default') = COALESCE(r.network_id, 'default')
+        WHERE s.node_id IS NOT NULL
+          AND r.status = 'committed'
+          AND r.old_alias = tasks.from_name
+          AND COALESCE(r.network_id, 'default') = COALESCE(tasks.network_id, 'default')
+        ORDER BY r.committed_at DESC
+        LIMIT 1
+      )
+      WHERE from_node_id IS NULL
+        AND EXISTS (
+          SELECT 1 FROM rename_txn r
+          JOIN sessions s
+            ON s.alias = r.new_alias
+           AND COALESCE(s.network_id, 'default') = COALESCE(r.network_id, 'default')
+          WHERE s.node_id IS NOT NULL
+            AND r.status = 'committed'
+            AND r.old_alias = tasks.from_name
+            AND COALESCE(r.network_id, 'default') = COALESCE(tasks.network_id, 'default')
+        )
+    `).changes;
+  } catch {}
+
+  const total = inboxDirect + inboxRenamed + tasksToDirect + tasksToRenamed + tasksFromDirect + tasksFromRenamed;
+  console.log(`[commhub] node_id backfill: inbox=${inboxDirect + inboxRenamed}, tasks.to=${tasksToDirect + tasksToRenamed}, tasks.from=${tasksFromDirect + tasksFromRenamed}, total=${total}`);
+}
+
+backfillMessageNodeIds();
+
 // ── P0: sessions alias uniqueness is network-scoped.
 // Older SQLite databases created `alias TEXT UNIQUE`, which prevents the same
 // agent alias from existing in two networks. SQLite cannot drop a UNIQUE
@@ -588,10 +769,14 @@ export function chainReplyToParent(childTaskId: string, replyText: string, reply
     if (parent.from_name && parent.from_name !== "hub" && parent.from_name !== "api") {
       try {
         const notifyId = `chain_${crypto.randomUUID().replace(/-/g, "").slice(0, 16)}`;
+        const notifyNode = db.get<{ node_id: string | null }>(
+          "SELECT node_id FROM sessions WHERE alias = ?1 AND COALESCE(network_id, 'default') = COALESCE(?2, 'default') ORDER BY updated_at DESC LIMIT 1",
+          [parent.from_name, parent.network_id ?? null]
+        );
         db.run(
-          `INSERT INTO inbox (id, session_name, type, priority, content, from_session, in_reply_to, requires_response, network_id)
-           VALUES (?1, ?2, 'reply', 'normal', ?3, ?4, ?5, 'none', ?6)`,
-          [notifyId, parent.from_name, `[${childAlias} 子任务完成]\n${currentReply.slice(0, 4000)}`, parent.to_name, parent.task_id, parent.network_id ?? null]
+          `INSERT INTO inbox (id, session_name, node_id, type, priority, content, from_session, in_reply_to, requires_response, network_id)
+           VALUES (?1, ?2, ?3, 'reply', 'normal', ?4, ?5, ?6, 'none', ?7)`,
+          [notifyId, parent.from_name, notifyNode?.node_id ?? null, `[${childAlias} 子任务完成]\n${currentReply.slice(0, 4000)}`, parent.to_name, parent.task_id, parent.network_id ?? null]
         );
       } catch {}
     }

package/src/event_bus.ts

@@ -0,0 +1,10 @@
+import { EventEmitter } from "events";
+
+export type RenameCommittedEvent = {
+  networkId: string | null;
+  old_alias: string;
+  new_alias: string;
+  node_id?: string | null;
+};
+
+export const eventBus = new EventEmitter();