@feynmanzhang/open-party 0.1.4 → 0.1.5

package/dist/claude-code/{open-party-0.1.1 → open-party-0.1.5}/dist/party-server.js

@@ -16,18 +16,352 @@ var init_config = __esm({
   "src/server/config.ts"() {
     "use strict";
     PARTY_PORT = parseInt(process.env.PARTY_PORT || "8000", 10);
-    HEARTBEAT_TIMEOUT = parseFloat(process.env.HEARTBEAT_TIMEOUT || "30");
-    CLEANUP_INTERVAL = parseFloat(process.env.CLEANUP_INTERVAL || "10");
+    HEARTBEAT_TIMEOUT = parseFloat(process.env.HEARTBEAT_TIMEOUT || "60");
+    CLEANUP_INTERVAL = parseFloat(process.env.CLEANUP_INTERVAL || "60");
     DISCOVERY_INTERVAL = parseFloat(process.env.DISCOVERY_INTERVAL || "20");
     REMOTE_STALE_FACTOR = parseInt(process.env.REMOTE_STALE_FACTOR || "3", 10);
     PROBE_TIMEOUT = parseFloat(process.env.PROBE_TIMEOUT || "5");
   }
 });
 
+// src/server/logger.ts
+import { existsSync, mkdirSync, appendFileSync, readdirSync, unlinkSync, statSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+function getEffectiveLevel() {
+  const env = (process.env.LOG_LEVEL || "info").toLowerCase().trim();
+  if (env in LEVEL_ORDER) return env;
+  return "info";
+}
+function initLogFile() {
+  if (!existsSync(LOG_DIR)) {
+    mkdirSync(LOG_DIR, { recursive: true });
+    return;
+  }
+  try {
+    const now = Date.now();
+    const cutoff = now - LOG_RETENTION_DAYS * 24 * 60 * 60 * 1e3;
+    const files = readdirSync(LOG_DIR);
+    for (const f of files) {
+      if (!f.endsWith("-open-party.log")) continue;
+      try {
+        const stat = statSync(join(LOG_DIR, f));
+        if (stat.mtimeMs < cutoff) {
+          unlinkSync(join(LOG_DIR, f));
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+}
+function getLogFilePath() {
+  const d = /* @__PURE__ */ new Date();
+  const yy = String(d.getFullYear()).slice(2);
+  const mm = String(d.getMonth() + 1).padStart(2, "0");
+  const dd = String(d.getDate()).padStart(2, "0");
+  return join(LOG_DIR, `${yy}-${mm}-${dd}-open-party.log`);
+}
+function shouldLog(level) {
+  return LEVEL_ORDER[level] >= LEVEL_ORDER[effectiveLevel];
+}
+function extractError(err) {
+  if (err instanceof Error) {
+    const stack = err.stack ? `
+${err.stack}` : "";
+    return `${err.message}${stack}`;
+  }
+  return String(err);
+}
+function format(level, tag, message) {
+  const now = /* @__PURE__ */ new Date();
+  const levelStr = level.toUpperCase().padEnd(5);
+  const yy = String(now.getFullYear()).slice(2);
+  const mm = String(now.getMonth() + 1).padStart(2, "0");
+  const dd = String(now.getDate()).padStart(2, "0");
+  const hh = String(now.getHours()).padStart(2, "0");
+  const min = String(now.getMinutes()).padStart(2, "0");
+  const ss = String(now.getSeconds()).padStart(2, "0");
+  const ts = `${yy}-${mm}-${dd} ${hh}:${min}:${ss}`;
+  return `${ts} [${levelStr}] [${tag}] ${message}`;
+}
+function output(consoleFn, level, tag, message) {
+  if (!shouldLog(level)) return;
+  const line = format(level, tag, message);
+  consoleFn(line);
+  try {
+    appendFileSync(getLogFilePath(), line + "\n", "utf-8");
+  } catch {
+  }
+}
+var LEVEL_ORDER, effectiveLevel, LOG_DIR, LOG_RETENTION_DAYS, logger;
+var init_logger = __esm({
+  "src/server/logger.ts"() {
+    "use strict";
+    LEVEL_ORDER = {
+      debug: 0,
+      info: 1,
+      warn: 2,
+      error: 3
+    };
+    effectiveLevel = getEffectiveLevel();
+    LOG_DIR = join(homedir(), ".open-party", "logs");
+    LOG_RETENTION_DAYS = 7;
+    initLogFile();
+    logger = {
+      info(tag, message, data) {
+        output(console.log, "info", tag, data ? `${message} ${JSON.stringify(data)}` : message);
+      },
+      warn(tag, message, data) {
+        output(console.warn, "warn", tag, data ? `${message} ${JSON.stringify(data)}` : message);
+      },
+      error(tag, message, err) {
+        const detail = err ? `: ${extractError(err)}` : "";
+        output(console.error, "error", tag, message + detail);
+      },
+      debug(tag, message, data) {
+        output(console.debug, "debug", tag, data ? `${message} ${JSON.stringify(data)}` : message);
+      }
+    };
+  }
+});
+
+// src/server/persistence.ts
+import { existsSync as existsSync2, readFileSync, writeFileSync, unlinkSync as unlinkSync2, renameSync, mkdirSync as mkdirSync2 } from "fs";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+function dataDirPath() {
+  const pluginData = process.env.CLAUDE_PLUGIN_DATA || "";
+  if (pluginData) return join2(pluginData, "data");
+  return join2(homedir2(), ".open-party", "data");
+}
+function runMigrations(raw2) {
+  const data = raw2;
+  if (!data || typeof data !== "object") {
+    throw new Error("Snapshot is not a valid object");
+  }
+  const version = typeof data.version === "number" ? data.version : 0;
+  let snapshot = {
+    version,
+    saved_at: typeof data.saved_at === "number" ? data.saved_at : 0,
+    agents: Array.isArray(data.agents) ? data.agents : [],
+    history: typeof data.history === "object" && data.history !== null && !Array.isArray(data.history) ? data.history : {}
+  };
+  for (const m of MIGRATORS) {
+    if (m.version > snapshot.version) {
+      snapshot = m.migrate(snapshot);
+      snapshot.version = m.version;
+    }
+  }
+  return snapshot;
+}
+function abortableSleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(resolve, ms);
+    signal?.addEventListener(
+      "abort",
+      () => {
+        clearTimeout(timer);
+        reject(new DOMException("Aborted", "AbortError"));
+      },
+      { once: true }
+    );
+  });
+}
+var CURRENT_SCHEMA_VERSION, SNAPSHOT_FILE, SHUTDOWN_MARKER_FILE, DEFAULT_SNAPSHOT_INTERVAL_MS, DEBOUNCE_MS, MIGRATORS, SnapshotManager;
+var init_persistence = __esm({
+  "src/server/persistence.ts"() {
+    "use strict";
+    init_logger();
+    CURRENT_SCHEMA_VERSION = 1;
+    SNAPSHOT_FILE = "snapshot.json";
+    SHUTDOWN_MARKER_FILE = "shutdown-marker.json";
+    DEFAULT_SNAPSHOT_INTERVAL_MS = 6e4;
+    DEBOUNCE_MS = 5e3;
+    MIGRATORS = [
+      // Future: { version: 2, migrate(snapshot) { ... } },
+    ];
+    SnapshotManager = class {
+      _dir;
+      _snapshotPath;
+      _markerPath;
+      _debounceTimer = null;
+      constructor(dataDir) {
+        this._dir = dataDir ?? dataDirPath();
+        this._snapshotPath = join2(this._dir, SNAPSHOT_FILE);
+        this._markerPath = join2(this._dir, SHUTDOWN_MARKER_FILE);
+        mkdirSync2(this._dir, { recursive: true });
+        const tmpPath = this._snapshotPath + ".tmp";
+        try {
+          if (existsSync2(tmpPath)) {
+            unlinkSync2(tmpPath);
+          }
+        } catch (error) {
+          logger.warn("Persistence", "Failed to clean up stale tmp file", error);
+        }
+      }
+      // ------------------------------------------------------------------
+      // Write / Load
+      // ------------------------------------------------------------------
+      /** Atomically write a snapshot of registry agents and message queue history. */
+      writeSnapshot(agents, history) {
+        const snapshot = {
+          version: CURRENT_SCHEMA_VERSION,
+          saved_at: Date.now(),
+          agents,
+          history
+        };
+        const serialized = JSON.stringify(snapshot, null, 2);
+        const tmpPath = this._snapshotPath + ".tmp";
+        try {
+          writeFileSync(tmpPath, serialized, "utf-8");
+          renameSync(tmpPath, this._snapshotPath);
+        } catch (error) {
+          logger.error("Persistence", "Failed to write snapshot", error);
+          try {
+            unlinkSync2(tmpPath);
+          } catch {
+          }
+          throw error;
+        }
+      }
+      /** Load and validate snapshot. Returns null if file missing or corrupt. */
+      loadSnapshot() {
+        if (!existsSync2(this._snapshotPath)) {
+          return null;
+        }
+        try {
+          const raw2 = JSON.parse(readFileSync(this._snapshotPath, "utf-8"));
+          return runMigrations(raw2);
+        } catch (error) {
+          logger.warn("Persistence", "Failed to load snapshot (starting fresh)", error);
+          return null;
+        }
+      }
+      // ------------------------------------------------------------------
+      // Hydration (restore in-memory state from snapshot)
+      // ------------------------------------------------------------------
+      /** Restore agents into registry. Overwrites host_ip with current selfIp. */
+      hydrateAgents(registry2, selfIp) {
+        const snapshot = this.loadSnapshot();
+        if (!snapshot || snapshot.agents.length === 0) return 0;
+        const now = Date.now() / 1e3;
+        let count = 0;
+        for (const agent of snapshot.agents) {
+          agent.last_heartbeat = now;
+          const info = registry2.register({
+            agent_id: agent.agent_id,
+            display_name: agent.display_name,
+            metadata: agent.metadata ?? {}
+          });
+          info.host_ip = selfIp;
+          count++;
+        }
+        return count;
+      }
+      /** Restore message history into queue. */
+      hydrateHistory(queue) {
+        const snapshot = this.loadSnapshot();
+        if (!snapshot || Object.keys(snapshot.history).length === 0) return 0;
+        let totalEntries = 0;
+        for (const [agentId, entries] of Object.entries(snapshot.history)) {
+          for (const entry of entries) {
+            queue.logToHistory(agentId, entry.direction, {
+              sender_id: entry.sender_id,
+              recipient_id: entry.recipient_id,
+              summary: entry.summary,
+              content: entry.content,
+              timestamp: entry.timestamp
+            });
+            totalEntries++;
+          }
+        }
+        return totalEntries;
+      }
+      // ------------------------------------------------------------------
+      // Shutdown marker
+      // ------------------------------------------------------------------
+      /** Write shutdown marker to detect interrupted shutdown on next start. */
+      writeShutdownMarker() {
+        try {
+          writeFileSync(
+            this._markerPath,
+            JSON.stringify({ started_at: Date.now() }),
+            "utf-8"
+          );
+        } catch (error) {
+          logger.warn("Persistence", "Failed to write shutdown marker", error);
+        }
+      }
+      /** Remove shutdown marker — called after successful shutdown. */
+      removeShutdownMarker() {
+        try {
+          if (existsSync2(this._markerPath)) {
+            unlinkSync2(this._markerPath);
+          }
+        } catch (error) {
+          logger.warn("Persistence", "Failed to remove shutdown marker", error);
+        }
+      }
+      /** Check if a shutdown marker exists (indicates previous shutdown was interrupted). */
+      hasShutdownMarker() {
+        return existsSync2(this._markerPath);
+      }
+      // ------------------------------------------------------------------
+      // Snapshot loop & debounce
+      // ------------------------------------------------------------------
+      /**
+       * Start periodic snapshot background loop.
+       * Writes snapshot every `intervalMs` milliseconds until signal is aborted.
+       */
+      async startSnapshotLoop(signal, getAgents, getHistory, intervalMs = DEFAULT_SNAPSHOT_INTERVAL_MS) {
+        while (!signal.aborted) {
+          try {
+            await abortableSleep(intervalMs, signal);
+          } catch (e) {
+            if (signal.aborted) break;
+            throw e;
+          }
+          if (signal.aborted) break;
+          try {
+            this.writeSnapshot(getAgents(), getHistory());
+          } catch (error) {
+            logger.warn("Persistence", "Periodic snapshot failed", error);
+          }
+        }
+      }
+      /**
+       * Schedule a debounced snapshot write.
+       * Multiple calls within DEBOUNCE_MS window are coalesced into one write.
+       */
+      scheduleSnapshot(getAgents, getHistory) {
+        if (this._debounceTimer !== null) {
+          clearTimeout(this._debounceTimer);
+        }
+        this._debounceTimer = setTimeout(() => {
+          this._debounceTimer = null;
+          try {
+            this.writeSnapshot(getAgents(), getHistory());
+          } catch (error) {
+            logger.warn("Persistence", "Debounced snapshot failed", error);
+          }
+        }, DEBOUNCE_MS);
+      }
+      /** Cancel pending debounced snapshot (called during shutdown). */
+      cancelDebounce() {
+        if (this._debounceTimer !== null) {
+          clearTimeout(this._debounceTimer);
+          this._debounceTimer = null;
+        }
+      }
+    };
+  }
+});
+
 // src/infra/tailscale.ts
 import { execFileSync, execSync } from "child_process";
-import { existsSync } from "fs";
-import { join } from "path";
+import { existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
 import { spawn as nodeSpawn } from "child_process";
 function parsePossiblyNoisyJson(raw2) {
   const trimmed = raw2.trim();
@@ -47,7 +381,7 @@ function runExec(cmd, timeout = 5e3) {
   });
 }
 function checkBinary(path, timeout = 3e3) {
-  if (!path || !existsSync(path)) return false;
+  if (!path || !existsSync3(path)) return false;
   try {
     execFileSync(path, ["--version"], { timeout, encoding: "utf-8", stdio: "pipe", windowsHide: true });
     return true;
@@ -64,9 +398,9 @@ function findTailscaleBinary() {
   } catch {
   }
   const knownPaths = process.platform === "win32" ? [
-    join(process.env.ProgramFiles || "C:\\Program Files", "Tailscale", "tailscale.exe"),
-    join(process.env["ProgramFiles(x86)"] || "C:\\Program Files (x86)", "Tailscale", "tailscale.exe"),
-    join(process.env.LOCALAPPDATA || "", "Tailscale", "tailscale.exe")
+    join3(process.env.ProgramFiles || "C:\\Program Files", "Tailscale", "tailscale.exe"),
+    join3(process.env["ProgramFiles(x86)"] || "C:\\Program Files (x86)", "Tailscale", "tailscale.exe"),
+    join3(process.env.LOCALAPPDATA || "", "Tailscale", "tailscale.exe")
   ] : [
     "/Applications/Tailscale.app/Contents/MacOS/Tailscale",
     "/usr/bin/tailscale",
@@ -110,7 +444,7 @@ function getTailnetHostname(binary) {
   ];
   let lastErr = null;
   for (const candidate of candidates) {
-    if (candidate.startsWith("/") && !existsSync(candidate)) continue;
+    if (candidate.startsWith("/") && !existsSync3(candidate)) continue;
     try {
       const stdout = runExec([candidate, "status", "--json"], 5e3);
       const parsed = stdout.trim() ? parsePossiblyNoisyJson(stdout) : {};
@@ -152,11 +486,11 @@ function execWithSudoFallback(cmd, timeout = 15e3) {
 function joinTailnet(authKey, timeout = 3e4) {
   const binary = getTailscaleBinary();
   try {
-    const output = execWithSudoFallback(
+    const output2 = execWithSudoFallback(
       [binary, "up", "--authkey", authKey],
       timeout
     );
-    return { success: true, output: output.trim() };
+    return { success: true, output: output2.trim() };
   } catch (e) {
     const err = e;
     return { success: false, output: (err.stderr ?? err.message ?? "").trim() };
@@ -182,11 +516,12 @@ function getTailscaleInstallationStatus() {
       };
     }
     return { state: "not_connected", binary };
-  } catch (e) {
+  } catch (error) {
+    console.error("[Tailscale] Failed to get installation status:", error);
     return {
       state: "not_connected",
       binary,
-      error: e.message
+      error: error instanceof Error ? error.message : String(error)
     };
   }
 }
@@ -196,9 +531,9 @@ function resetTailscaleBinaryCache() {
 function logoutTailscale(timeout = 15e3) {
   const binary = getTailscaleBinary();
   try {
-    const output = runExec([binary, "logout"], timeout);
+    const output2 = runExec([binary, "logout"], timeout);
     resetTailscaleBinaryCache();
-    return { success: true, output: output.trim() };
+    return { success: true, output: output2.trim() };
   } catch (e) {
     const err = e;
     return { success: false, output: (err.stderr ?? err.message ?? "").trim() };
@@ -362,6 +697,14 @@ var init_message_queue = __esm({
       removeAgentHistory(agentId) {
         this._history.delete(agentId);
       }
+      /** Return a shallow copy of the full history map (for persistence snapshots). */
+      getHistorySnapshot() {
+        const copy = {};
+        for (const [agentId, entries] of this._history) {
+          copy[agentId] = [...entries];
+        }
+        return copy;
+      }
     };
   }
 });
@@ -376,15 +719,14 @@ function classifyFetchError(error) {
   if (error instanceof DOMException && error.name === "AbortError") return null;
   return null;
 }
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
 var UNKNOWN, PARTY_SERVER, DEGRADED, SUSPECT, DOWN, NOT_SERVER, MAYBE, MAYBE_MAX_RETRIES, BACKOFF_BASE, BACKOFF_CAP, FAILURE_SUSPECT, FAILURE_DOWN, PeerDiscovery;
 var init_peer_discovery = __esm({
   "src/server/peer-discovery.ts"() {
     "use strict";
     init_config();
     init_tailscale();
+    init_persistence();
+    init_logger();
     UNKNOWN = "UNKNOWN";
     PARTY_SERVER = "PARTY_SERVER";
     DEGRADED = "DEGRADED";
@@ -446,14 +788,14 @@ var init_peer_discovery = __esm({
       // ------------------------------------------------------------------
       // Main discovery loop
       // ------------------------------------------------------------------
-      async runLoop() {
-        while (true) {
+      async runLoop(signal) {
+        while (!signal?.aborted) {
           try {
             await this.discoveryCycle();
           } catch (e) {
-            console.error("[Discovery] Cycle failed:", e);
+            logger.error("Discovery", "Cycle failed", e);
           }
-          await sleep(DISCOVERY_INTERVAL * 1e3);
+          await abortableSleep(DISCOVERY_INTERVAL * 1e3, signal);
         }
       }
       async discoveryCycle() {
@@ -486,8 +828,8 @@ var init_peer_discovery = __esm({
         let status;
         try {
           status = readTailscaleStatus();
-        } catch {
-          console.warn("[Discovery] Failed to read Tailscale status");
+        } catch (error) {
+          logger.warn("Discovery", "Failed to read Tailscale status", error);
           return [];
         }
         const peersRaw = status.Peer;
@@ -512,7 +854,7 @@ var init_peer_discovery = __esm({
       // Peer probing
       // ------------------------------------------------------------------
       async probePeer(ps) {
-        ps.lastProbeAt = performance.now() / 1e3;
+        ps.lastProbeAt = Date.now() / 1e3;
         const healthy = await this.checkHealth(ps.ip);
         if (healthy === null) {
           this.handleProbeFailure(ps, true);
@@ -581,7 +923,7 @@ var init_peer_discovery = __esm({
         const old = ps.status;
         ps.status = newStatus;
         if (old !== newStatus) {
-          console.log(`[Discovery] Peer ${ps.ip}: ${old} -> ${newStatus}`);
+          logger.info("Discovery", `Peer ${ps.ip}: ${old} -> ${newStatus}`);
         }
         if (newStatus === NOT_SERVER) {
           const retries = ps.maybeRetries > 0 ? ps.maybeRetries : 1;
@@ -624,8 +966,8 @@ var init_peer_discovery = __esm({
               this._remoteAgents.delete(aid);
             }
           }
-        } catch {
-          console.warn(`[Discovery] Failed to sync agents from ${peerIp}`);
+        } catch (error) {
+          logger.warn("Discovery", `Failed to sync agents from ${peerIp}`, error);
         }
       }
       // ------------------------------------------------------------------
@@ -681,7 +1023,8 @@ var init_registry = __esm({
         return info;
       }
       remove(agentId) {
-        return this._agents.delete(agentId);
+        const existed = this._agents.delete(agentId);
+        return existed;
       }
       heartbeat(agentId) {
         const info = this._agents.get(agentId);
@@ -719,9 +1062,14 @@ __export(state_exports, {
   STARTED_AT: () => STARTED_AT,
   discovery: () => discovery,
   getSelfIp: () => getSelfIp,
+  getSnapshotManager: () => getSnapshotManager,
+  initSnapshotManager: () => initSnapshotManager,
+  lifecycleController: () => lifecycleController,
   messageQueue: () => messageQueue,
   refreshSelfIp: () => refreshSelfIp,
-  registry: () => registry
+  registry: () => registry,
+  scheduleSnapshot: () => scheduleSnapshot,
+  snapshotManager: () => snapshotManager
 });
 function resolveSelfIp() {
   try {
@@ -741,7 +1089,19 @@ function refreshSelfIp() {
   _selfIp = resolveSelfIp();
   return _selfIp;
 }
-var _selfIp, STARTED_AT, registry, messageQueue, discovery;
+function scheduleSnapshot() {
+  snapshotManager?.scheduleSnapshot(
+    () => registry.listAll(),
+    () => messageQueue.getHistorySnapshot()
+  );
+}
+function initSnapshotManager(mgr) {
+  snapshotManager = mgr;
+}
+function getSnapshotManager() {
+  return snapshotManager;
+}
+var _selfIp, STARTED_AT, registry, messageQueue, discovery, snapshotManager, lifecycleController;
 var init_state = __esm({
   "src/server/state.ts"() {
     "use strict";
@@ -754,6 +1114,8 @@ var init_state = __esm({
     registry = new AgentRegistry(getSelfIp());
     messageQueue = new MessageQueue();
     discovery = new PeerDiscovery(getSelfIp());
+    snapshotManager = null;
+    lifecycleController = new AbortController();
   }
 });
 
@@ -3610,10 +3972,12 @@ var serve = (options, listeningListener) => {
 
 // src/server/index.ts
 init_config();
+init_persistence();
+init_logger();
 init_state();
-import { mkdirSync, writeFileSync, unlinkSync } from "fs";
-import { join as join2, dirname } from "path";
-import { homedir } from "os";
+import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync2, unlinkSync as unlinkSync3 } from "fs";
+import { join as join4, dirname as dirname2 } from "path";
+import { homedir as homedir3 } from "os";
 
 // src/server/models.ts
 function sanitizeAgentInfo(info) {
@@ -3626,6 +3990,7 @@ function sanitizeAgentList(agents) {
 
 // src/server/routes/agent.ts
 init_config();
+init_logger();
 var agentRoutes = new Hono2();
 async function forwardToPeer(peerIp, envelope) {
   const url = `http://${peerIp}:${PARTY_PORT}/proxy/receive`;
@@ -3644,21 +4009,26 @@ async function forwardToPeer(peerIp, envelope) {
   }
 }
 agentRoutes.post("/register", async (c) => {
-  const { registry: registry2 } = await Promise.resolve().then(() => (init_state(), state_exports));
+  const { registry: registry2, scheduleSnapshot: scheduleSnapshot3 } = await Promise.resolve().then(() => (init_state(), state_exports));
   const req = await c.req.json();
   const info = registry2.register(req);
+  scheduleSnapshot3();
+  logger.info("Agent", `Registered: ${info.agent_id} (display: "${info.display_name ?? "N/A"}")`);
   return c.json(sanitizeAgentInfo(info));
 });
 agentRoutes.post("/remove", async (c) => {
-  const { registry: registry2 } = await Promise.resolve().then(() => (init_state(), state_exports));
+  const { registry: registry2, scheduleSnapshot: scheduleSnapshot3 } = await Promise.resolve().then(() => (init_state(), state_exports));
   const req = await c.req.json();
   const removed = registry2.remove(req.agent_id);
+  if (removed) scheduleSnapshot3();
+  logger.info("Agent", removed ? `Removed: ${req.agent_id}` : `Remove failed: ${req.agent_id} (not found)`);
   return c.json({ status: removed ? "removed" : "not_found" });
 });
 agentRoutes.post("/heartbeat", async (c) => {
   const { registry: registry2 } = await Promise.resolve().then(() => (init_state(), state_exports));
   const req = await c.req.json();
   const info = registry2.heartbeat(req.agent_id);
+  logger.info("Agent", `Heartbeat from ${req.agent_id}`);
   return c.json({ status: "ok", last_heartbeat: info.last_heartbeat });
 });
 agentRoutes.get("/list", async (c) => {
@@ -3669,7 +4039,7 @@ agentRoutes.get("/list", async (c) => {
   return c.json({ agents: sanitizeAgentList(allAgents), count: allAgents.length });
 });
 agentRoutes.post("/send", async (c) => {
-  const { registry: registry2, messageQueue: messageQueue2, discovery: discovery2 } = await Promise.resolve().then(() => (init_state(), state_exports));
+  const { registry: registry2, messageQueue: messageQueue2, discovery: discovery2, scheduleSnapshot: scheduleSnapshot3 } = await Promise.resolve().then(() => (init_state(), state_exports));
   const envelope = await c.req.json();
   const recipient = envelope.recipient_id;
   if (!recipient) {
@@ -3680,6 +4050,8 @@ agentRoutes.post("/send", async (c) => {
     const count = messageQueue2.enqueue(recipient, stamped);
     messageQueue2.logToHistory(envelope.sender_id, "sent", stamped);
     messageQueue2.logToHistory(recipient, "received", stamped);
+    scheduleSnapshot3();
+    logger.info("Agent", `Send ${envelope.sender_id} -> ${recipient}: delivered_locally`);
     return c.json({ status: "delivered_locally", target: recipient });
   }
   const peerIp = discovery2.getPeerForAgent(recipient);
@@ -3688,12 +4060,16 @@ agentRoutes.post("/send", async (c) => {
       const result = await forwardToPeer(peerIp, envelope);
       if (result.status === "forwarded") {
         messageQueue2.logToHistory(envelope.sender_id, "sent", { ...envelope, timestamp: envelope.timestamp ?? Date.now() / 1e3 });
+        scheduleSnapshot3();
+        logger.info("Agent", `Send ${envelope.sender_id} -> ${recipient}: forwarded (peer ${peerIp})`);
       }
       return c.json(result);
     } else {
+      logger.info("Agent", `Send ${envelope.sender_id} -> ${recipient}: peer_unreachable (peer ${peerIp})`);
       return c.json({ status: "peer_unreachable", target: peerIp });
     }
   }
+  logger.info("Agent", `Send ${envelope.sender_id} -> ${recipient}: agent_not_found`);
   return c.json({ status: "agent_not_found", target: recipient });
 });
 agentRoutes.get("/messages/:agent_id", async (c) => {
@@ -3715,6 +4091,7 @@ agentRoutes.get("/history/:agent_id", async (c) => {
 init_config();
 init_tailscale();
 init_state();
+init_logger();
 var proxyRoutes = new Hono2();
 proxyRoutes.get("/health", async (c) => {
   let hostname = "127.0.0.1";
@@ -3739,13 +4116,13 @@ proxyRoutes.post("/receive", async (c) => {
   if (envelope.recipient_id) {
     messageQueue.enqueue(envelope.recipient_id, stamped);
     messageQueue.logToHistory(envelope.recipient_id, "received", stamped);
-    console.log(`[\u6536\u5230\u6D88\u606F] ${envelope.sender_id} -> ${envelope.recipient_id}: ${envelope.content}`);
+    logger.info("Proxy", `Received msg ${envelope.sender_id} -> ${envelope.recipient_id}`);
   } else {
     for (const agent of registry.listAll()) {
       messageQueue.enqueue(agent.agent_id, stamped);
       messageQueue.logToHistory(agent.agent_id, "received", stamped);
     }
-    console.log(`[\u5E7F\u64AD\u6D88\u606F] ${envelope.sender_id} -> all: ${envelope.content}`);
+    logger.info("Proxy", `Broadcast from ${envelope.sender_id} to all agents`);
   }
   return c.json({ status: "received" });
 });
@@ -3763,10 +4140,10 @@ proxyRoutes.post("/send/:target_ip", async (c) => {
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify(payload)
     });
-    console.log(`[\u53D1\u9001\u6210\u529F] \u76EE\u6807 ${targetIp}`);
+    logger.info("Proxy", `Forwarded to ${targetIp}`);
     return c.json({ status: "forwarded", target: targetIp });
   } catch (e) {
-    console.log(`[\u53D1\u9001\u5931\u8D25] \u76EE\u6807 ${targetIp}, \u9519\u8BEF: ${e.message}`);
+    logger.warn("Proxy", `Forward to ${targetIp} failed: ${e.message}`);
     return c.json({ status: "error", target: targetIp, error: e.message });
   }
 });
@@ -4420,6 +4797,16 @@ body::after{
     }).join('');
   }
 
+  // Build agent_id \u2192 display_name lookup from local + remote agents
+  function buildNameMap(data) {
+    const map = {};
+    const all = [...(data.agents.local_agents || []), ...(data.agents.remote_agents || [])];
+    for (const a of all) { map[a.agent_id] = a.display_name || a.agent_id; }
+    return map;
+  }
+
+  function resolveName(map, id) { return map[id] || id; }
+
   function renderMessages(data) {
     const container = $('#msgFeed');
     const msgs = data.messages.recent || [];
@@ -4429,12 +4816,14 @@ body::after{
       return;
     }
 
+    const names = buildNameMap(data);
+
     container.innerHTML = msgs.map(function(m) {
       const dir = m.direction === 'received' ? 'received' : '';
       const arrow = m.direction === 'received' ? '&#8592;' : '&#8594;';
       const flow = m.direction === 'received'
-        ? m.sender_id + ' <span class="arrow">' + arrow + '</span> ' + (m.agent_id || '?')
-        : (m.agent_id || '?') + ' <span class="arrow">' + arrow + '</span> ' + (m.recipient_id || 'broadcast');
+        ? resolveName(names, m.sender_id) + ' <span class="arrow">' + arrow + '</span> ' + resolveName(names, m.agent_id)
+        : resolveName(names, m.agent_id) + ' <span class="arrow">' + arrow + '</span> ' + resolveName(names, m.recipient_id) || 'broadcast';
       return '<div class="msg-item ' + dir + '">'
         + '<div class="msg-top">'
         + '<div class="msg-flow">' + flow + '</div>'
@@ -4839,6 +5228,7 @@ body::after{
 // src/server/routes/dashboard.ts
 init_tailscale();
 init_state();
+init_logger();
 var dashboardRoutes = new Hono2();
 dashboardRoutes.get("/", (c) => {
   return c.html(DASHBOARD_HTML);
@@ -4864,10 +5254,14 @@ dashboardRoutes.get("/api/overview", async (c) => {
   const localAgents = sanitizeAgentList(registry.listAll());
   const remoteEntries = discovery.getRemoteAgentEntries();
   const peerStates = discovery.getPeerStates();
+  const seen = /* @__PURE__ */ new Set();
   const recentMessages = [];
   for (const agent of localAgents) {
     const history = messageQueue.getHistory(agent.agent_id, 5);
     for (const entry of history) {
+      const key = `${entry.sender_id}:${entry.recipient_id ?? ""}:${Math.floor(entry.timestamp)}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
       recentMessages.push({ agent_id: agent.agent_id, ...entry });
     }
   }
@@ -4931,6 +5325,7 @@ dashboardRoutes.post("/api/join-network", async (c) => {
       return c.json({ success: false, output: "auth_key is required" }, 400);
     }
     const result = joinTailnet(authKey);
+    logger.info("Dashboard", `Join network: ${result.success ? "success" : "failed"}`);
     return c.json(result, result.success ? 200 : 500);
   } catch (e) {
     return c.json({ success: false, output: e.message }, 500);
@@ -4939,6 +5334,7 @@ dashboardRoutes.post("/api/join-network", async (c) => {
 var activeLogin = null;
 dashboardRoutes.post("/api/logout", async (c) => {
   const result = logoutTailscale();
+  logger.info("Dashboard", `Logout: ${result.success ? "success" : "failed"}`);
   if (result.success) {
     resetTailscaleBinaryCache();
     refreshSelfIp();
@@ -4951,6 +5347,7 @@ dashboardRoutes.post("/api/tailscale-login", async (c) => {
   }
   const { promise, process: process2 } = startInteractiveLogin();
   activeLogin = { process: process2 };
+  logger.info("Dashboard", "Tailscale login initiated");
   const result = await promise;
   if (result.success && result.url) {
     activeLogin.url = result.url;
@@ -4962,6 +5359,7 @@ dashboardRoutes.post("/api/tailscale-login", async (c) => {
 dashboardRoutes.post("/api/install-tailscale", async (c) => {
   const { installTailscale: installTailscale2 } = await Promise.resolve().then(() => (init_tailscale_installer(), tailscale_installer_exports));
   const result = await installTailscale2(process.platform);
+  logger.info("Dashboard", `Install Tailscale: ${result.success ? "success" : "failed"}`);
   if (result.success) {
     resetTailscaleBinaryCache();
   }
@@ -4970,48 +5368,135 @@ dashboardRoutes.post("/api/install-tailscale", async (c) => {
 
 // src/server/index.ts
 async function periodicCleanup() {
+  while (!lifecycleController.signal.aborted) {
+    try {
+      const removed = registry.cleanupStale(HEARTBEAT_TIMEOUT);
+      if (removed.length > 0) {
+        logger.info("Cleanup", `Removed ${removed.length} stale agent(s): ${removed.join(", ")}`);
+      }
+    } catch (e) {
+      logger.error("Cleanup", "Error during cleanup", e);
+    }
+    await abortableSleep(CLEANUP_INTERVAL * 1e3, lifecycleController.signal);
+  }
 }
 var app = new Hono2();
 app.use("*", cors());
+app.use("*", async (c, next) => {
+  const start = Date.now();
+  await next();
+  const ms = Date.now() - start;
+  const ip = c.req.header("x-forwarded-for")?.split(",")[0]?.trim() ?? c.info?.remote?.address ?? "unknown";
+  const path = c.req.path;
+  if (path === "/proxy/health") {
+    logger.debug("HTTP", `${c.req.method} ${path} ${c.res.status} ${ms}ms ${ip}`);
+  } else {
+    logger.info("HTTP", `${c.req.method} ${path} ${c.res.status} ${ms}ms ${ip}`);
+  }
+});
+app.onError((err, c) => {
+  logger.error("HTTP", `${c.req.method} ${c.req.path} failed (${err.status ?? 500}): ${err.message}`, err);
+  return c.json({
+    status: "error",
+    error: (err.status ?? 500) >= 500 ? "Internal server error" : err.message
+  }, err.status ?? 500);
+});
 app.route("/agent", agentRoutes);
 app.route("/proxy", proxyRoutes);
 app.route("/dashboard", dashboardRoutes);
 function pidFilePath() {
   const pluginData = process.env.CLAUDE_PLUGIN_DATA || "";
-  if (pluginData) return join2(pluginData, "server.pid");
-  return join2(homedir(), ".open-party", "server.pid");
+  if (pluginData) return join4(pluginData, "server.pid");
+  return join4(homedir3(), ".open-party", "server.pid");
+}
+var shutdownInitiated = false;
+async function performShutdown(server, pidPath) {
+  if (shutdownInitiated) return;
+  shutdownInitiated = true;
+  logger.info("Shutdown", "Shutting down Party Server...");
+  try {
+    lifecycleController.abort();
+    getSnapshotManager()?.cancelDebounce();
+    try {
+      getSnapshotManager()?.writeSnapshot(registry.listAll(), messageQueue.getHistorySnapshot());
+      logger.info("Shutdown", "Final snapshot written.");
+    } catch (error) {
+      logger.error("Shutdown", "Failed to write final snapshot", error);
+    }
+    if (server.closeAllConnections) {
+      server.closeAllConnections();
+    }
+    if (process.platform === "win32") {
+      await new Promise((r) => setTimeout(r, 500));
+    }
+    await new Promise((resolve, reject) => {
+      server.close((err) => err ? reject(err) : resolve());
+    });
+    if (process.platform === "win32") {
+      await new Promise((r) => setTimeout(r, 500));
+    }
+    getSnapshotManager()?.removeShutdownMarker();
+    try {
+      unlinkSync3(pidPath);
+    } catch {
+    }
+    logger.info("Shutdown", "Party Server shut down cleanly.");
+  } catch (error) {
+    logger.error("Shutdown", "Error during shutdown sequence", error);
+  } finally {
+    process.exit(0);
+  }
 }
 async function main() {
   const pidPath = pidFilePath();
-  mkdirSync(dirname(pidPath), { recursive: true });
-  writeFileSync(pidPath, String(process.pid));
-  console.log(`Starting Party Server on port ${PARTY_PORT} (Tailscale IP: ${getSelfIp()})`);
+  mkdirSync3(dirname2(pidPath), { recursive: true });
+  writeFileSync2(pidPath, String(process.pid));
+  initSnapshotManager(new SnapshotManager());
+  const sm = getSnapshotManager();
+  let recoveredAgents = 0;
+  let recoveredHistoryEntries = 0;
+  if (sm.hasShutdownMarker()) {
+    logger.info("Recovery", "Previous shutdown was interrupted (shutdown marker found).");
+  }
+  const savedSnapshot = sm.loadSnapshot();
+  if (savedSnapshot) {
+    recoveredAgents = sm.hydrateAgents(registry, getSelfIp());
+    recoveredHistoryEntries = sm.hydrateHistory(messageQueue);
+    if (recoveredAgents > 0 || recoveredHistoryEntries > 0) {
+      logger.info(
+        "Recovery",
+        `Recovered ${recoveredAgents} agent(s), ${recoveredHistoryEntries} history entry/entries.`
+      );
+    }
+  }
+  logger.info("Server", `Starting Party Server on port ${PARTY_PORT} (Tailscale IP: ${getSelfIp()})`);
   process.on("SIGHUP", () => {
   });
   const server = serve({ fetch: app.fetch, port: PARTY_PORT });
-  const discoveryPromise = discovery.runLoop();
+  const discoveryPromise = discovery.runLoop(lifecycleController.signal);
   const cleanupPromise = periodicCleanup();
-  const shutdown = () => {
-    console.log("\nShutting down Party Server...");
-    try {
-      unlinkSync(pidPath);
-    } catch {
-    }
-    server.close();
-    process.exit(0);
-  };
-  process.on("SIGINT", shutdown);
-  process.on("SIGTERM", shutdown);
-  await Promise.race([discoveryPromise, cleanupPromise]);
+  const snapshotLoopPromise = sm.startSnapshotLoop(
+    lifecycleController.signal,
+    () => registry.listAll(),
+    () => messageQueue.getHistorySnapshot()
+  );
+  const shutdownHandler = () => void performShutdown(server, pidPath);
+  process.on("SIGINT", shutdownHandler);
+  process.on("SIGTERM", shutdownHandler);
+  app.post("/api/shutdown", (c) => {
+    void performShutdown(server, pidPath);
+    return c.json({ status: "shutting_down" });
+  });
+  await Promise.race([discoveryPromise, cleanupPromise, snapshotLoopPromise]);
 }
 main().catch((e) => {
-  console.error("Fatal error:", e);
+  logger.error("Server", "Fatal error", e);
   process.exit(1);
 });
 process.on("uncaughtException", (e) => {
-  console.error("Uncaught exception:", e);
+  logger.error("Server", "Uncaught exception", e);
 });
 process.on("unhandledRejection", (e) => {
-  console.error("Unhandled rejection:", e);
+  logger.error("Server", "Unhandled rejection", e);
 });
 //# sourceMappingURL=party-server.js.map