@politeia/openclaw-bridge 0.1.2

package/tools/user-board.mjs

@@ -0,0 +1,760 @@
+#!/usr/bin/env node
+
+import http from "node:http";
+import { execFile } from "node:child_process";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+const HOST = process.env.HOST ?? "127.0.0.1";
+const PORT = Number(process.env.PORT ?? "8790");
+const OPENCLAW_BIN = process.env.OPENCLAW_BIN ?? "openclaw";
+const CACHE_TTL_MS = Number(process.env.AGENTCOMM_BOARD_CACHE_TTL_MS ?? "5000");
+const ASSET_DIR = process.env.AGENTCOMM_BOARD_ASSET_DIR ?? path.resolve(__dirname, "../dist/user-board");
+
+const cache = new Map();
+
+async function cached(key, loader, ttlMs = CACHE_TTL_MS) {
+  const hit = cache.get(key);
+  if (hit && Date.now() - hit.loadedAt <= ttlMs) {
+    return hit.value;
+  }
+  const value = await loader();
+  cache.set(key, { loadedAt: Date.now(), value });
+  return value;
+}
+
+async function callGateway(method, params = null, options = {}) {
+  const args = ["gateway", "call", method, "--json", "--expect-final"];
+  if (params) {
+    args.push("--params", JSON.stringify(params));
+  }
+  const { stdout } = await execFileAsync(OPENCLAW_BIN, args, {
+    timeout: options.timeoutMs ?? 12_000,
+  });
+  return stdout.trim().length > 0 ? JSON.parse(stdout) : {};
+}
+
+async function getWorkspaceStatus() {
+  if (process.env.AGENTCOMM_USER_WORKSPACE_DIR) {
+    return {
+      ok: true,
+      source: "AGENTCOMM_USER_WORKSPACE_DIR",
+      rootDir: process.env.AGENTCOMM_USER_WORKSPACE_DIR,
+      workspaceRootDir: process.env.AGENTCOMM_USER_WORKSPACE_DIR,
+      offline: false,
+    };
+  }
+
+  try {
+    return {
+      ...(await cached("workspaceStatus", () => callGateway("communityBridge.workspaceStatus", null, { timeoutMs: 8000 }))),
+      source: "openclaw-gateway",
+      offline: false,
+    };
+  } catch (error) {
+    const fallback = await resolveFallbackWorkspace();
+    return {
+      ok: Boolean(fallback.rootDir),
+      source: "local-fallback",
+      offline: true,
+      error: error instanceof Error ? error.message : String(error),
+      rootDir: fallback.rootDir,
+      workspaceRootDir: fallback.rootDir,
+      communityAgentId: fallback.communityAgentId,
+    };
+  }
+}
+
+async function resolveFallbackWorkspace() {
+  const config = await readJsonFile(path.join(os.homedir(), ".openclaw", "openclaw.json"), {});
+  const bridgeConfig = config?.plugins?.entries?.["openclaw-bridge"]?.config ?? {};
+  const communityAgentId =
+    typeof bridgeConfig.communityAgentId === "string" && bridgeConfig.communityAgentId.length > 0
+      ? bridgeConfig.communityAgentId
+      : null;
+  const agentId = typeof bridgeConfig.agentId === "string" && bridgeConfig.agentId.length > 0 ? bridgeConfig.agentId : "main";
+  const candidates = [
+    process.env.AGENTCOMM_USER_WORKSPACE_DIR,
+    path.join(os.homedir(), ".openclaw", "agents", agentId, "agent", "community"),
+    communityAgentId ? path.join(os.homedir(), ".openclaw", "workspace", ".community", communityAgentId) : null,
+  ].filter(Boolean);
+
+  return {
+    communityAgentId,
+    rootDir: candidates.find((candidate) => existsSync(candidate)) ?? candidates[0] ?? null,
+  };
+}
+
+function workspaceFiles(rootDir) {
+  return {
+    state: path.join(rootDir, "state.json"),
+    persona: path.join(rootDir, "persona", "profile.json"),
+    delegationPolicy: path.join(rootDir, "persona", "delegation-policy.json"),
+    auditLog: path.join(rootDir, "persona", "audit-log.jsonl"),
+    inbox: path.join(rootDir, "inbox", "received-direct-messages.jsonl"),
+    sentDms: path.join(rootDir, "outbox", "sent-direct-messages.jsonl"),
+    roomsIndex: path.join(rootDir, "rooms", "index.json"),
+    roomsDir: path.join(rootDir, "rooms"),
+    meetingSummaries: path.join(rootDir, "rooms", "meeting-summaries.jsonl"),
+    posts: path.join(rootDir, "feed-cache", "posts.jsonl"),
+    skills: path.join(rootDir, "skills", "index.json"),
+    pendingActions: path.join(rootDir, "confirmations", "pending-actions.jsonl"),
+    decisions: path.join(rootDir, "confirmations", "action-decisions.jsonl"),
+    results: path.join(rootDir, "confirmations", "action-results.jsonl"),
+    activities: path.join(rootDir, "persona", "activity-log.jsonl"),
+    handoff: path.join(rootDir, "subagent-workspace", ".agentcomm", "inbox", "handoff.jsonl"),
+    boardState: path.join(rootDir, "board-state.json"),
+  };
+}
+
+async function readJsonFile(filePath, fallback = null) {
+  try {
+    const raw = await readFile(filePath, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return fallback;
+  }
+}
+
+async function writeJsonFile(filePath, value) {
+  await mkdir(path.dirname(filePath), { recursive: true });
+  await writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}
+
+async function readJsonLines(filePath) {
+  try {
+    const raw = await readFile(filePath, "utf8");
+    return raw
+      .split("\n")
+      .map((line) => line.trim())
+      .filter(Boolean)
+      .map((line) => JSON.parse(line));
+  } catch {
+    return [];
+  }
+}
+
+async function getAgentDirectory() {
+  try {
+    const response = await cached("agentDirectory", () => callGateway("communityBridge.listAgents", null, { timeoutMs: 8000 }));
+    const items = Array.isArray(response?.items) ? response.items : [];
+    return new Map(items.map((agent) => [agent.agent_id, agent]));
+  } catch {
+    return new Map();
+  }
+}
+
+async function loadBoardData() {
+  const status = await getWorkspaceStatus();
+  const rootDir = status.rootDir ?? status.workspaceRootDir;
+  if (!rootDir) {
+    throw new Error("Community workspace is unavailable.");
+  }
+
+  const files = workspaceFiles(rootDir);
+  const [
+    state,
+    persona,
+    delegationPolicy,
+    auditLog,
+    inbox,
+    sentDms,
+    roomsRaw,
+    meetingSummaries,
+    posts,
+    skillsRaw,
+    pendingActions,
+    decisions,
+    results,
+    activities,
+    handoffs,
+    boardState,
+    agentDirectory,
+  ] = await Promise.all([
+    readJsonFile(files.state, {}),
+    readJsonFile(files.persona, {}),
+    readJsonFile(files.delegationPolicy, null),
+    readJsonLines(files.auditLog),
+    readJsonLines(files.inbox),
+    readJsonLines(files.sentDms),
+    readJsonFile(files.roomsIndex, []),
+    readJsonLines(files.meetingSummaries),
+    readJsonLines(files.posts),
+    readJsonFile(files.skills, []),
+    readJsonLines(files.pendingActions),
+    readJsonLines(files.decisions),
+    readJsonLines(files.results),
+    readJsonLines(files.activities),
+    readJsonLines(files.handoff),
+    readJsonFile(files.boardState, { readThreads: {} }),
+    getAgentDirectory(),
+  ]);
+
+  const data = {
+    status,
+    rootDir,
+    files,
+    state,
+    persona,
+    delegationPolicy,
+    auditLog,
+    inbox,
+    sentDms,
+    roomsRaw: Array.isArray(roomsRaw) ? roomsRaw : [],
+    rooms: await buildRooms(files, Array.isArray(roomsRaw) ? roomsRaw : [], meetingSummaries, agentDirectory),
+    posts,
+    skills: Array.isArray(skillsRaw) ? skillsRaw : [],
+    pendingActions,
+    decisions,
+    results,
+    activities,
+    handoffs,
+    boardState: isRecord(boardState) ? boardState : { readThreads: {} },
+    agentDirectory,
+  };
+
+  return buildBoardView(data);
+}
+
+function buildBoardView(data) {
+  const ownAgentId =
+    data.state?.communityAgentId ??
+    data.persona?.communityAgentId ??
+    data.status?.communityAgentId ??
+    data.status?.state?.communityAgentId ??
+    null;
+  const agentDirectory = data.agentDirectory;
+  const ownDisplayName = agentLabel(agentDirectory, ownAgentId, data.persona?.displayName ?? ownAgentId ?? "Community Agent");
+  const decisions = byActionId(data.decisions);
+  const results = byActionId(data.results);
+  const threads = buildThreads(data, ownAgentId, agentDirectory);
+  const pendingDecisions = data.pendingActions
+    .filter((action) => !decisions.has(action.action_id))
+    .sort((a, b) => timeValue(b.created_at) - timeValue(a.created_at));
+  const acceptedNotApplied = data.pendingActions
+    .filter((action) => {
+      const decision = decisions.get(action.action_id);
+      return decision?.decision === "accepted" && !results.has(action.action_id);
+    })
+    .sort((a, b) => timeValue(b.created_at) - timeValue(a.created_at));
+
+  return {
+    generatedAt: new Date().toISOString(),
+    bridge: {
+      offline: Boolean(data.status?.offline),
+      source: data.status?.source ?? "unknown",
+      error: data.status?.error ?? null,
+      connected: data.status?.offline ? false : data.status?.ok !== false,
+    },
+    agent: {
+      communityAgentId: ownAgentId,
+      displayName: ownDisplayName,
+      workspaceRootDir: data.rootDir,
+      lastKeepaliveAt: data.state?.lastKeepaliveAt ?? null,
+      online: isRecent(data.state?.lastKeepaliveAt),
+    },
+    summary: {
+      pendingDecisionCount: pendingDecisions.length,
+      acceptedNotAppliedCount: acceptedNotApplied.length,
+      threadCount: threads.length,
+      roomCount: data.rooms.length,
+      activityCount: data.activities.length,
+      handoffCount: data.handoffs.length,
+    },
+    authorization: buildAuthorizationSummary(data.delegationPolicy),
+    decisions: pendingDecisions.map((action) => formatAction(action, data, agentDirectory)),
+    acceptedNotApplied: acceptedNotApplied.map((action) => formatAction(action, data, agentDirectory)),
+    activity: buildActivity(data, agentDirectory),
+    threads,
+    rooms: data.rooms,
+    posts: data.posts
+      .slice()
+      .sort((a, b) => timeValue(b.created_at) - timeValue(a.created_at))
+      .slice(0, 20)
+      .map((post) => ({
+        id: post.post_id ?? post.envelope_id,
+        title: post.payload?.title ?? post.title ?? "Untitled",
+        body: post.payload?.body ?? post.body ?? "",
+        createdAt: post.created_at ?? null,
+        intent: post.payload?.intent ?? post.intent ?? null,
+      })),
+    skillOffers: data.skills
+      .slice()
+      .sort((a, b) => timeValue(b.created_at) - timeValue(a.created_at))
+      .slice(0, 20)
+      .map((offer) => ({
+        offerId: offer.offer_id,
+        name: offer.name ?? offer.skill_slug,
+        skillSlug: offer.skill_slug,
+        source: offer.source ?? "unknown",
+        status: offer.status ?? "staged",
+        riskLevel: offer.risk_level ?? "medium",
+        description: offer.recommendation_reason ?? offer.description ?? "",
+        createdAt: offer.created_at ?? null,
+      })),
+    debug: {
+      rootDir: data.rootDir,
+      counts: {
+        inbox: data.inbox.length,
+        sentDms: data.sentDms.length,
+        pendingActions: data.pendingActions.length,
+        decisions: data.decisions.length,
+        auditLog: data.auditLog.length,
+      },
+    },
+  };
+}
+
+function buildThreads(data, ownAgentId, agentDirectory) {
+  const readThreads = isRecord(data.boardState?.readThreads) ? data.boardState.readThreads : {};
+  const messages = [
+    ...data.inbox.map((dm) => ({
+      id: dm.dm_id,
+      envelopeId: dm.envelope_id,
+      peerAgentId: dm.sender_agent_id,
+      speaker: "peer",
+      message: dm.message,
+      intent: dm.intent ?? null,
+      createdAt: dm.created_at,
+    })),
+    ...data.sentDms.map((dm) => {
+      const payload = dm.payload ?? {};
+      const intent = dm.intent ?? payload.intent ?? null;
+      const isAutoReceipt = intent === "dm.auto_receipt" || dm.action === "dm.auto_receipt";
+      return {
+        id: dm.dm_id ?? dm.envelope_id,
+        envelopeId: dm.envelope_id,
+        peerAgentId: dm.recipient_agent_id ?? dm.target_agent_id ?? dm.target?.agent_id,
+        speaker: isAutoReceipt ? "agent" : "user",
+        message: dm.message ?? payload.message,
+        intent,
+        createdAt: dm.created_at,
+      };
+    }),
+  ].filter((message) => message.peerAgentId && message.message);
+
+  const groups = new Map();
+  for (const message of messages) {
+    const peer = message.peerAgentId;
+    const thread =
+      groups.get(peer) ??
+      {
+        peerAgentId: peer,
+        displayName: agentLabel(agentDirectory, peer, peer),
+        messages: [],
+        unreadCount: 0,
+        lastMessageAt: null,
+        lastMessagePreview: "",
+      };
+    thread.messages.push(message);
+    groups.set(peer, thread);
+  }
+
+  return [...groups.values()]
+    .map((thread) => {
+      thread.messages.sort((a, b) => timeValue(a.createdAt) - timeValue(b.createdAt));
+      const last = thread.messages.at(-1);
+      const readAt = readThreads[thread.peerAgentId] ?? null;
+      thread.unreadCount = thread.messages.filter(
+        (message) => message.speaker === "peer" && timeValue(message.createdAt) > timeValue(readAt),
+      ).length;
+      thread.lastMessageAt = last?.createdAt ?? null;
+      thread.lastMessagePreview = last?.message ?? "";
+      thread.ownAgentId = ownAgentId;
+      return thread;
+    })
+    .sort((a, b) => timeValue(b.lastMessageAt) - timeValue(a.lastMessageAt));
+}
+
+async function buildRooms(files, rooms, meetingSummaries, agentDirectory) {
+  const formatted = [];
+  const summariesByRoom = new Map();
+  for (const summary of Array.isArray(meetingSummaries) ? meetingSummaries : []) {
+    if (!summary?.room_id) continue;
+    const existing = summariesByRoom.get(summary.room_id);
+    if (!existing || timeValue(summary.confirmed_at ?? summary.created_at) > timeValue(existing.confirmed_at ?? existing.created_at)) {
+      summariesByRoom.set(summary.room_id, summary);
+    }
+  }
+  for (const room of rooms) {
+    if (!room?.room_id) continue;
+    const messages = await readJsonLines(path.join(files.roomsDir, `${safeFileSegment(room.room_id)}.jsonl`));
+    const roomMessages = messages
+      .filter((message) => message?.room_id === room.room_id && typeof message.message === "string")
+      .sort((a, b) => timeValue(a.created_at) - timeValue(b.created_at))
+      .map((message) => ({
+        id: message.message_id ?? message.delivery_id ?? message.envelope_id,
+        envelopeId: message.envelope_id,
+        senderAgentId: message.sender_agent_id,
+        senderDisplayName: agentLabel(agentDirectory, message.sender_agent_id, message.sender_agent_id),
+        speakerKind: message.speaker_kind === "agent" ? "agent" : "human",
+        speakerLabel: message.speaker_label ?? null,
+        message: message.message,
+        createdAt: message.created_at,
+      }));
+    const last = roomMessages.at(-1);
+    formatted.push({
+      roomId: room.room_id,
+      topic: room.topic ?? "Untitled room",
+      members: Array.isArray(room.members) ? room.members : [],
+      memberLabels: Array.isArray(room.members)
+        ? room.members.map((member) => agentLabel(agentDirectory, member, member))
+        : [],
+      status: room.status ?? "open",
+      sourceNegotiationId: room.source_negotiation_id ?? null,
+      createdAt: room.created_at ?? null,
+      updatedAt: room.updated_at ?? last?.createdAt ?? null,
+      lastMessageAt: last?.createdAt ?? null,
+      lastMessagePreview: last?.message ?? "",
+      summary: summariesByRoom.get(room.room_id) ?? null,
+      messages: roomMessages,
+    });
+  }
+
+  return formatted.sort((a, b) => timeValue(b.lastMessageAt ?? b.updatedAt) - timeValue(a.lastMessageAt ?? a.updatedAt));
+}
+
+function buildActivity(data, agentDirectory) {
+  const auditActivities = data.activities.map((activity) => ({
+    id: activity.activity_id ?? activity.audit_id ?? `${activity.kind}:${activity.created_at}`,
+    kind: activity.kind ?? "activity",
+    riskLevel: activity.risk_level ?? "low",
+    title: activity.summary ?? activity.kind ?? "Activity",
+    body: activity.payload ? summarizePayload(activity.payload) : activity.summary ?? "",
+    createdAt: activity.created_at,
+  }));
+  const auditLog = data.auditLog
+    .filter((record) => record.action !== "policy_decision")
+    .map((record) => ({
+      id: record.audit_id,
+      kind: record.action ?? record.kind ?? "audit",
+      riskLevel: record.decision === "ask" ? "medium" : "low",
+      title: record.action ?? record.kind ?? "Audit",
+      body: record.reason ?? record.result ?? record.target_agent_id ?? "",
+      createdAt: record.created_at,
+    }));
+  const skillOffers = data.skills.map((offer) => ({
+    id: offer.offer_id,
+    kind: "skill.offer",
+    riskLevel: offer.risk_level ?? "medium",
+    title: `${offer.name ?? offer.skill_slug} recommended`,
+    body: offer.recommendation_reason ?? offer.description ?? "",
+    createdAt: offer.created_at,
+  }));
+  const sent = data.sentDms.map((dm) => ({
+    id: dm.dm_id ?? dm.envelope_id,
+    kind: dm.intent === "dm.auto_receipt" || dm.payload?.intent === "dm.auto_receipt" ? "dm.auto_receipt" : "dm.sent",
+    riskLevel: "low",
+    title:
+      dm.intent === "dm.auto_receipt" || dm.payload?.intent === "dm.auto_receipt"
+        ? "Auto receipt sent"
+        : `Message sent to ${agentLabel(agentDirectory, dm.recipient_agent_id ?? dm.target_agent_id, "agent")}`,
+    body: dm.message ?? dm.payload?.message ?? "",
+    createdAt: dm.created_at,
+  }));
+
+  return [...auditActivities, ...auditLog, ...skillOffers, ...sent]
+    .filter((activity) => activity.createdAt)
+    .sort((a, b) => timeValue(b.createdAt) - timeValue(a.createdAt))
+    .slice(0, 40);
+}
+
+function formatAction(action, data, agentDirectory) {
+  const peerAgentId = action.payload?.source_agent_id ?? action.payload?.sender_agent_id ?? action.payload?.target_agent_id ?? null;
+  const sourceEventId = action.source_event_id ?? action.payload?.dm_id ?? action.payload?.envelope_id ?? null;
+  const sourceMessage =
+    data.inbox.find((dm) => dm.dm_id === sourceEventId || dm.envelope_id === sourceEventId) ??
+    data.inbox.find((dm) => dm.sender_agent_id === peerAgentId);
+  return {
+    actionId: action.action_id,
+    kind: action.kind,
+    title: action.title ?? action.kind ?? "Pending action",
+    summary: action.summary ?? "",
+    createdAt: action.created_at ?? null,
+    riskLevel: action.payload?.risk_level ?? (action.kind === "install_skill" ? "medium" : "medium"),
+    peerAgentId,
+    peerDisplayName: agentLabel(agentDirectory, peerAgentId, peerAgentId),
+    sourceMessage: sourceMessage
+      ? {
+          dmId: sourceMessage.dm_id,
+          envelopeId: sourceMessage.envelope_id,
+          message: sourceMessage.message,
+          createdAt: sourceMessage.created_at,
+        }
+      : null,
+    skillSlug: action.payload?.skill_slug ?? null,
+    roomId: action.payload?.room_id ?? null,
+    todos: Array.isArray(action.payload?.todos) ? action.payload.todos : [],
+  };
+}
+
+function buildAuthorizationSummary(policy) {
+  const rules = Array.isArray(policy?.rules) ? policy.rules : [];
+  const byDecision = (decision) => rules.filter((rule) => rule.decision === decision).map((rule) => rule.action);
+  return {
+    protocolVersion: policy?.protocolVersion ?? "unknown",
+    automatic: byDecision("allow"),
+    ask: byDecision("ask"),
+    blocked: byDecision("deny"),
+    autoReceipt: {
+      enabled: Boolean(policy?.autoReceipt?.enabled),
+      message: policy?.autoReceipt?.message ?? null,
+    },
+  };
+}
+
+async function markThreadRead(rootDir, peerAgentId) {
+  const files = workspaceFiles(rootDir);
+  const boardState = await readJsonFile(files.boardState, { readThreads: {} });
+  const next = isRecord(boardState) ? boardState : { readThreads: {} };
+  next.readThreads = isRecord(next.readThreads) ? next.readThreads : {};
+  next.readThreads[peerAgentId] = new Date().toISOString();
+  await writeJsonFile(files.boardState, next);
+  cache.delete("board");
+}
+
+async function parseJsonBody(req) {
+  const chunks = [];
+  for await (const chunk of req) {
+    chunks.push(Buffer.from(chunk));
+  }
+  const text = Buffer.concat(chunks).toString("utf8");
+  if (!text.trim()) return {};
+  return JSON.parse(text);
+}
+
+function byActionId(records) {
+  return new Map(records.map((record) => [record.action_id, record]));
+}
+
+function agentLabel(agentDirectory, agentId, fallback = "Unknown Agent") {
+  if (!agentId) return fallback;
+  const item = agentDirectory.get(agentId);
+  return item?.display_name ?? fallback ?? agentId;
+}
+
+function isRecent(value, maxAgeMs = 90_000) {
+  if (!value) return false;
+  const time = Date.parse(value);
+  return Number.isFinite(time) && Date.now() - time <= maxAgeMs;
+}
+
+function timeValue(value) {
+  const time = Date.parse(value ?? "");
+  return Number.isFinite(time) ? time : 0;
+}
+
+function summarizePayload(payload) {
+  if (!isRecord(payload)) return "";
+  const message = payload.message ?? payload.summary ?? payload.reason ?? payload.skill_slug;
+  return typeof message === "string" ? message : JSON.stringify(payload);
+}
+
+function safeFileSegment(value) {
+  return String(value).replace(/[^a-zA-Z0-9._-]+/g, "_");
+}
+
+function isRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+
+function json(res, status, payload) {
+  res.writeHead(status, {
+    "Content-Type": "application/json; charset=utf-8",
+    "Cache-Control": "no-store",
+  });
+  res.end(`${JSON.stringify(payload, null, 2)}\n`);
+}
+
+function html(res, status, payload) {
+  res.writeHead(status, {
+    "Content-Type": "text/html; charset=utf-8",
+    "Cache-Control": "no-store",
+  });
+  res.end(payload);
+}
+
+async function staticFile(res, fileName) {
+  const safeName = path.basename(fileName);
+  const filePath = path.join(ASSET_DIR, safeName);
+  const contentType = safeName.endsWith(".css")
+    ? "text/css; charset=utf-8"
+    : safeName.endsWith(".js")
+      ? "application/javascript; charset=utf-8"
+      : "application/octet-stream";
+  try {
+    const body = await readFile(filePath);
+    res.writeHead(200, {
+      "Content-Type": contentType,
+      "Cache-Control": "no-store",
+    });
+    res.end(body);
+  } catch {
+    json(res, 404, { error: "asset not found", asset: safeName, assetDir: ASSET_DIR });
+  }
+}
+
+function renderAppShell() {
+  return `<!doctype html>
+<html lang="zh-CN">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>AgentComm Delegation Console</title>
+    <link rel="stylesheet" href="/assets/app.css" />
+  </head>
+  <body>
+    <div id="app"></div>
+    <script type="module" src="/assets/app.js"></script>
+  </body>
+</html>`;
+}
+
+const server = http.createServer(async (req, res) => {
+  const url = new URL(req.url ?? "/", `http://${HOST}:${PORT}`);
+  const method = req.method ?? "GET";
+
+  try {
+    if (method === "GET" && url.pathname === "/") {
+      html(res, 200, renderAppShell());
+      return;
+    }
+
+    const assetMatch = url.pathname.match(/^\/assets\/([^/]+)$/);
+    if (method === "GET" && assetMatch) {
+      await staticFile(res, decodeURIComponent(assetMatch[1]));
+      return;
+    }
+
+    if (method === "GET" && url.pathname === "/api/board") {
+      json(res, 200, await loadBoardData());
+      return;
+    }
+
+    if (method === "GET" && url.pathname === "/healthz") {
+      const data = await loadBoardData();
+      json(res, 200, { ok: true, bridge: data.bridge, agent: data.agent });
+      return;
+    }
+
+    const readMatch = url.pathname.match(/^\/api\/threads\/([^/]+)\/read$/);
+    if (method === "POST" && readMatch) {
+      const data = await loadBoardData();
+      await markThreadRead(data.agent.workspaceRootDir, decodeURIComponent(readMatch[1]));
+      json(res, 200, { ok: true });
+      return;
+    }
+
+    const sendMatch = url.pathname.match(/^\/api\/conversations\/([^/]+)\/send$/);
+    if (method === "POST" && sendMatch) {
+      const peerAgentId = decodeURIComponent(sendMatch[1]);
+      const body = await parseJsonBody(req);
+      const message = typeof body.message === "string" ? body.message.trim() : "";
+      if (!message) {
+        json(res, 400, { error: "message is required" });
+        return;
+      }
+      json(
+        res,
+        200,
+        await callGateway("communityBridge.dmSend", {
+          targetAgentId: peerAgentId,
+          message,
+          intent: "user-board.dm.compose",
+        }),
+      );
+      cache.clear();
+      return;
+    }
+
+    const roomSendMatch = url.pathname.match(/^\/api\/rooms\/([^/]+)\/send$/);
+    if (method === "POST" && roomSendMatch) {
+      const roomId = decodeURIComponent(roomSendMatch[1]);
+      const body = await parseJsonBody(req);
+      const message = typeof body.message === "string" ? body.message.trim() : "";
+      if (!message) {
+        json(res, 400, { error: "message is required" });
+        return;
+      }
+      json(
+        res,
+        200,
+        await callGateway("communityBridge.roomSend", {
+          roomId,
+          message,
+          speakerKind: "human",
+          intent: "user-board.room.compose",
+        }),
+      );
+      cache.clear();
+      return;
+    }
+
+    const actionApplyMatch = url.pathname.match(/^\/api\/actions\/([^/]+)\/apply$/);
+    if (method === "POST" && actionApplyMatch) {
+      json(res, 200, await callGateway("communityBridge.applyAcceptedAction", { actionId: decodeURIComponent(actionApplyMatch[1]) }));
+      cache.clear();
+      return;
+    }
+
+    const actionMatch = url.pathname.match(/^\/api\/actions\/([^/]+)$/);
+    if (method === "POST" && actionMatch) {
+      const actionId = decodeURIComponent(actionMatch[1]);
+      const body = await parseJsonBody(req);
+      if (body.decision === "reject") {
+        json(
+          res,
+          200,
+          await callGateway("communityBridge.rejectAction", {
+            actionId,
+            reason: "rejected from local user board",
+            decidedBy: "user",
+          }),
+        );
+        cache.clear();
+        return;
+      }
+
+      const data = await loadBoardData();
+      const action = data.decisions.find((item) => item.actionId === actionId);
+      if (action?.kind === "reply_to_dm") {
+        const message = typeof body.message === "string" ? body.message.trim() : "";
+        if (!message) {
+          json(res, 400, { error: "reply message is required" });
+          return;
+        }
+        await callGateway("communityBridge.dmSend", {
+          targetAgentId: action.peerAgentId,
+          message,
+          intent: "user-board.dm.reply",
+        });
+      }
+      const result = await callGateway("communityBridge.confirmAction", {
+        actionId,
+        reason: action?.kind === "reply_to_dm" ? "reply sent from local user board" : "confirmed from local user board",
+        decidedBy: "user",
+      });
+      if (action?.kind === "meeting_summary") {
+        await callGateway("communityBridge.applyAcceptedAction", { actionId });
+      }
+      cache.clear();
+      json(res, 200, result);
+      return;
+    }
+
+    json(res, 404, { error: "not found", path: url.pathname });
+  } catch (error) {
+    json(res, 500, { error: error instanceof Error ? error.message : String(error) });
+  }
+});
+
+server.listen(PORT, HOST, () => {
+  console.log(`[${new Date().toISOString()}] AgentComm local user board listening on http://${HOST}:${PORT}`);
+});