@feynmanzhang/open-party 0.1.4 → 0.1.6

package/dist/claude-code/{open-party-0.1.0 → open-party-0.1.6}/.claude-plugin/plugin.json

@@ -1,5 +1,5 @@
 {
   "name": "open-party",
-  "version": "0.1.0",
+  "version": "0.1.6",
   "description": "Decentralized Agent communication network for Claude Code"
 }

package/dist/claude-code/open-party-0.1.6/BUILD_INFO.json

@@ -0,0 +1,6 @@
+{
+  "version": "0.1.6",
+  "git_commit": "0cf1dfc",
+  "build_timestamp": "2026-05-31T15:23:22.538Z",
+  "source_path": "src/client/claude-code/"
+}

package/dist/claude-code/{open-party-0.1.1 → open-party-0.1.6}/dist/hook-handler.js

@@ -4,8 +4,8 @@
 // src/client/claude-code/src/hook-handler.ts
 import { randomUUID as randomUUID2 } from "crypto";
 
-// src/client/claude-code/src/client.ts
-var PartyServerClient = class {
+// src/client/shared/client.ts
+var PartyHttpClient = class {
   baseUrl;
   timeout;
   constructor(baseUrl = "http://127.0.0.1:8000", timeout = 5e3) {
@@ -76,11 +76,10 @@ var PartyServerClient = class {
   }
 };
 
-// src/client/claude-code/src/session.ts
-import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "fs";
+// src/client/shared/session-store.ts
+import { existsSync, mkdirSync, readFileSync, readdirSync, unlinkSync, writeFileSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
-import { randomUUID } from "crypto";
 var SESSION_DIR = join(homedir(), ".open-party");
 var SESSIONS_DIR = join(SESSION_DIR, "sessions");
 var AGENTS_DIR = join(SESSION_DIR, "agents");
@@ -99,6 +98,9 @@ function readSession(sessionId) {
   if (!existsSync(path)) return void 0;
   return JSON.parse(readFileSync(path, "utf-8"));
 }
+
+// src/client/shared/id.ts
+import { randomUUID } from "crypto";
 function generateAgentId() {
   return `agent-${randomUUID().slice(0, 12)}`;
 }
@@ -134,7 +136,7 @@ function generateDisplayName() {
 }
 
 // src/client/claude-code/src/stdin-reader.ts
-var SAFETY_TIMEOUT_MS = 3e4;
+var SAFETY_TIMEOUT_MS = 5e3;
 var PARSE_DELAY_MS = 50;
 function isStdinAvailable() {
   try {
@@ -217,9 +219,17 @@ async function readJsonFromStdin() {
   });
 }
 
-// src/client/claude-code/src/server-manager.ts
+// src/client/shared/server-manager.ts
 import { spawn, execSync } from "child_process";
-import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, unlinkSync as unlinkSync2, mkdirSync as mkdirSync2, openSync } from "fs";
+import {
+  existsSync as existsSync2,
+  readFileSync as readFileSync2,
+  writeFileSync as writeFileSync2,
+  unlinkSync as unlinkSync2,
+  mkdirSync as mkdirSync2,
+  openSync,
+  closeSync
+} from "fs";
 import { join as join2, resolve, dirname } from "path";
 import { homedir as homedir2 } from "os";
 import { fileURLToPath } from "url";
@@ -227,15 +237,19 @@ var __dirname = dirname(fileURLToPath(import.meta.url));
 var DEFAULT_PORT = parseInt(process.env.PARTY_PORT || "8000", 10);
 var HEALTH_URL = `http://127.0.0.1:${DEFAULT_PORT}/proxy/health`;
 var STARTUP_TIMEOUT = 1e4;
-function pidFile() {
+function pidFileDir() {
   const pluginData = process.env.CLAUDE_PLUGIN_DATA || "";
-  if (pluginData) return join2(pluginData, "server.pid");
-  return join2(homedir2(), ".open-party", "server.pid");
+  if (pluginData) return pluginData;
+  return join2(homedir2(), ".open-party");
 }
-function logFile() {
-  const pluginData = process.env.CLAUDE_PLUGIN_DATA || "";
-  if (pluginData) return join2(pluginData, "server.log");
-  return join2(homedir2(), ".open-party", "server.log");
+function pidFilePath() {
+  return join2(pidFileDir(), "server.pid");
+}
+function logFilePath() {
+  return join2(pidFileDir(), "server.log");
+}
+function lockFilePath() {
+  return join2(pidFileDir(), "starting.lock");
 }
 function pluginRoot() {
   if (process.env.CLAUDE_PLUGIN_ROOT) return process.env.CLAUDE_PLUGIN_ROOT;
@@ -260,7 +274,7 @@ async function isRunning() {
   }
 }
 function writePid(pid) {
-  const path = pidFile();
+  const path = pidFilePath();
   const dir = dirname(path);
   if (!existsSync2(dir)) mkdirSync2(dir, { recursive: true });
   writeFileSync2(path, String(pid));
@@ -268,14 +282,34 @@ function writePid(pid) {
 async function sleep(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
-async function ensureServerRunning() {
-  if (await isRunning()) return;
+function acquireStartLock() {
+  const lockPath = lockFilePath();
+  try {
+    const fd = openSync(lockPath, "wx");
+    writeFileSync2(lockPath, String(process.pid));
+    return { acquired: true, fd };
+  } catch {
+    return { acquired: false, fd: -1 };
+  }
+}
+function releaseStartLock(fd) {
+  if (fd >= 0) {
+    try {
+      closeSync(fd);
+    } catch {
+    }
+  }
+  try {
+    unlinkSync2(lockFilePath());
+  } catch {
+  }
+}
+async function spawnAndWait() {
   const serverScript = join2(pluginRoot(), "dist", "party-server.js");
   if (!existsSync2(serverScript)) {
-    console.error(`[Open Party] Server script not found: ${serverScript}`);
-    return;
+    throw new Error(`[Open Party] Server script not found: ${serverScript}`);
   }
-  const logPath = logFile();
+  const logPath = logFilePath();
   mkdirSync2(dirname(logPath), { recursive: true });
   const logFd = openSync(logPath, "a");
   const proc = spawn(process.execPath, [serverScript], {
@@ -293,10 +327,42 @@ async function ensureServerRunning() {
     if (await isRunning()) return;
     await sleep(500);
   }
+  let alive = false;
   try {
     process.kill(proc.pid, 0);
+    alive = true;
   } catch {
-    console.error(`[Open Party] Server crashed during startup. Check log: ${logPath}`);
+  }
+  if (!alive) {
+    throw new Error(
+      `[Open Party] Server crashed during startup (PID ${proc.pid}). Check log: ${logPath}`
+    );
+  }
+  throw new Error(
+    `[Open Party] Server did not become healthy within ${STARTUP_TIMEOUT}ms (PID ${proc.pid}). Check log: ${logPath}`
+  );
+}
+async function waitForExisting() {
+  const deadline = Date.now() + STARTUP_TIMEOUT;
+  while (Date.now() < deadline) {
+    if (await isRunning()) return;
+    await sleep(500);
+  }
+  throw new Error(
+    `[Open Party] Another process is starting the server but it did not become healthy within ${STARTUP_TIMEOUT}ms`
+  );
+}
+async function ensureServerRunning() {
+  if (await isRunning()) return;
+  const { acquired, fd } = acquireStartLock();
+  if (acquired) {
+    try {
+      await spawnAndWait();
+    } finally {
+      releaseStartLock(fd);
+    }
+  } else {
+    await waitForExisting();
   }
 }
 
@@ -304,7 +370,7 @@ async function ensureServerRunning() {
 var PARTY_SERVER_URL = process.env.PARTY_SERVER_URL || "http://127.0.0.1:8000";
 async function handleSessionStart(sessionId, source) {
   await ensureServerRunning();
-  const client = new PartyServerClient(PARTY_SERVER_URL);
+  const client = new PartyHttpClient(PARTY_SERVER_URL);
   const existing = readSession(sessionId);
   if (existing && (source === "clear" || source === "compact" || source === "resume")) {
     const agentId2 = existing.agent_id;
@@ -313,53 +379,53 @@ async function handleSessionStart(sessionId, source) {
       try {
         await client.register(agentId2, displayName2, { type: "claude-code" });
         console.error(`[Open Party] Re-registered as ${agentId2} (${displayName2})`);
-      } catch (e) {
-        console.error(`[Open Party] Re-registration failed: ${e.message}`);
+      } catch (error) {
+        console.error("[Open Party] Re-registration failed, will retry on next session:", error);
       }
       writeSession(sessionId, agentId2, displayName2, PARTY_SERVER_URL);
     }
-    let agents2 = [];
+    let agents = [];
     let pendingMessages = [];
     try {
-      agents2 = await client.listAgents();
+      agents = await client.listAgents();
       if (source === "resume") {
         pendingMessages = await client.checkMessages(agentId2);
       }
-    } catch {
+    } catch (error) {
+      console.error("[Open Party] Failed to fetch agent list/messages:", error);
     }
-    outputContext(agentId2, displayName2, agents2, pendingMessages);
+    outputContext(agentId2, displayName2, agents, pendingMessages);
     return;
   }
   const agentId = generateAgentId();
   const displayName = generateDisplayName();
   try {
-    await client.register(agentId, displayName, { type: "claude-code" });
+    const [, agents] = await Promise.all([
+      client.register(agentId, displayName, { type: "claude-code" }),
+      client.listAgents()
+    ]);
     console.error(`[Open Party] Registered as ${agentId} (${displayName})`);
-  } catch (e) {
-    console.error(`[Open Party] Registration failed: ${e.message}`);
+    writeSession(sessionId, agentId, displayName, PARTY_SERVER_URL);
+    outputContext(agentId, displayName, agents, []);
+    return;
+  } catch (error) {
+    console.error("[Open Party] Registration failed:", error);
     writeSession(sessionId, agentId, displayName, PARTY_SERVER_URL);
     outputContext(agentId, displayName, [], []);
     return;
   }
-  writeSession(sessionId, agentId, displayName, PARTY_SERVER_URL);
-  let agents = [];
-  try {
-    agents = await client.listAgents();
-  } catch {
-  }
-  outputContext(agentId, displayName, agents, []);
 }
 async function handleSessionEnd(sessionId) {
   const session = readSession(sessionId);
   if (!session) return;
   const agentId = session.agent_id;
   const serverUrl = session.server_url;
-  const client = new PartyServerClient(serverUrl);
+  const client = new PartyHttpClient(serverUrl);
   try {
     await client.remove(agentId);
     console.error(`[Open Party] Unregistered ${agentId}`);
-  } catch (e) {
-    console.error(`[Open Party] Unregister failed: ${e.message}`);
+  } catch (error) {
+    console.error("[Open Party] Unregister failed:", error);
   }
 }
 async function handleUserPromptSubmit(sessionId) {
@@ -367,11 +433,12 @@ async function handleUserPromptSubmit(sessionId) {
   if (!session) return;
   const agentId = session.agent_id;
   const serverUrl = session.server_url;
-  const client = new PartyServerClient(serverUrl);
+  const client = new PartyHttpClient(serverUrl);
   let messages;
   try {
     messages = await client.checkMessages(agentId);
-  } catch {
+  } catch (error) {
+    console.error("[Open Party] Failed to check messages:", error);
     return;
   }
   if (!messages.length) return;
@@ -548,8 +615,8 @@ async function main() {
   }
   process.exit(0);
 }
-main().catch((e) => {
-  console.error(`[Open Party] Fatal: ${e.message}`);
+main().catch((error) => {
+  console.error("[Open Party] Fatal:", error);
   process.exit(1);
 });
 //# sourceMappingURL=hook-handler.js.map

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

@@ -21098,8 +21098,13 @@ var StdioServerTransport = class {
   }
 };
 
-// src/client/claude-code/src/client.ts
-var PartyServerClient = class {
+// src/client/claude-code/src/mcp-server.ts
+import { readFileSync as readFileSync3, existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
+import { homedir as homedir3 } from "os";
+
+// src/client/shared/client.ts
+var PartyHttpClient = class {
   baseUrl;
   timeout;
   constructor(baseUrl = "http://127.0.0.1:8000", timeout = 5e3) {
@@ -21170,11 +21175,10 @@ var PartyServerClient = class {
   }
 };
 
-// src/client/claude-code/src/session.ts
-import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "fs";
+// src/client/shared/session-store.ts
+import { existsSync, mkdirSync, readFileSync, readdirSync, unlinkSync, writeFileSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
-import { randomUUID } from "crypto";
 var SESSION_DIR = join(homedir(), ".open-party");
 var SESSIONS_DIR = join(SESSION_DIR, "sessions");
 var AGENTS_DIR = join(SESSION_DIR, "agents");
@@ -21190,9 +21194,20 @@ function readSessionByAgent(agentId) {
   return readSession(mapping.session_id);
 }
 
-// src/client/claude-code/src/server-manager.ts
+// src/client/shared/id.ts
+import { randomUUID } from "crypto";
+
+// src/client/shared/server-manager.ts
 import { spawn, execSync } from "child_process";
-import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, unlinkSync as unlinkSync2, mkdirSync as mkdirSync2, openSync } from "fs";
+import {
+  existsSync as existsSync2,
+  readFileSync as readFileSync2,
+  writeFileSync as writeFileSync2,
+  unlinkSync as unlinkSync2,
+  mkdirSync as mkdirSync2,
+  openSync,
+  closeSync
+} from "fs";
 import { join as join2, resolve, dirname } from "path";
 import { homedir as homedir2 } from "os";
 import { fileURLToPath } from "url";
@@ -21200,15 +21215,19 @@ var __dirname = dirname(fileURLToPath(import.meta.url));
 var DEFAULT_PORT = parseInt(process.env.PARTY_PORT || "8000", 10);
 var HEALTH_URL = `http://127.0.0.1:${DEFAULT_PORT}/proxy/health`;
 var STARTUP_TIMEOUT = 1e4;
-function pidFile() {
+function pidFileDir() {
   const pluginData = process.env.CLAUDE_PLUGIN_DATA || "";
-  if (pluginData) return join2(pluginData, "server.pid");
-  return join2(homedir2(), ".open-party", "server.pid");
+  if (pluginData) return pluginData;
+  return join2(homedir2(), ".open-party");
 }
-function logFile() {
-  const pluginData = process.env.CLAUDE_PLUGIN_DATA || "";
-  if (pluginData) return join2(pluginData, "server.log");
-  return join2(homedir2(), ".open-party", "server.log");
+function pidFilePath() {
+  return join2(pidFileDir(), "server.pid");
+}
+function logFilePath() {
+  return join2(pidFileDir(), "server.log");
+}
+function lockFilePath() {
+  return join2(pidFileDir(), "starting.lock");
 }
 function pluginRoot() {
   if (process.env.CLAUDE_PLUGIN_ROOT) return process.env.CLAUDE_PLUGIN_ROOT;
@@ -21233,7 +21252,7 @@ async function isRunning() {
   }
 }
 function writePid(pid) {
-  const path = pidFile();
+  const path = pidFilePath();
   const dir = dirname(path);
   if (!existsSync2(dir)) mkdirSync2(dir, { recursive: true });
   writeFileSync2(path, String(pid));
@@ -21241,14 +21260,34 @@ function writePid(pid) {
 async function sleep(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
-async function ensureServerRunning() {
-  if (await isRunning()) return;
+function acquireStartLock() {
+  const lockPath = lockFilePath();
+  try {
+    const fd = openSync(lockPath, "wx");
+    writeFileSync2(lockPath, String(process.pid));
+    return { acquired: true, fd };
+  } catch {
+    return { acquired: false, fd: -1 };
+  }
+}
+function releaseStartLock(fd) {
+  if (fd >= 0) {
+    try {
+      closeSync(fd);
+    } catch {
+    }
+  }
+  try {
+    unlinkSync2(lockFilePath());
+  } catch {
+  }
+}
+async function spawnAndWait() {
   const serverScript = join2(pluginRoot(), "dist", "party-server.js");
   if (!existsSync2(serverScript)) {
-    console.error(`[Open Party] Server script not found: ${serverScript}`);
-    return;
+    throw new Error(`[Open Party] Server script not found: ${serverScript}`);
   }
-  const logPath = logFile();
+  const logPath = logFilePath();
   mkdirSync2(dirname(logPath), { recursive: true });
   const logFd = openSync(logPath, "a");
   const proc = spawn(process.execPath, [serverScript], {
@@ -21266,16 +21305,48 @@ async function ensureServerRunning() {
     if (await isRunning()) return;
     await sleep(500);
   }
+  let alive = false;
   try {
     process.kill(proc.pid, 0);
+    alive = true;
   } catch {
-    console.error(`[Open Party] Server crashed during startup. Check log: ${logPath}`);
+  }
+  if (!alive) {
+    throw new Error(
+      `[Open Party] Server crashed during startup (PID ${proc.pid}). Check log: ${logPath}`
+    );
+  }
+  throw new Error(
+    `[Open Party] Server did not become healthy within ${STARTUP_TIMEOUT}ms (PID ${proc.pid}). Check log: ${logPath}`
+  );
+}
+async function waitForExisting() {
+  const deadline = Date.now() + STARTUP_TIMEOUT;
+  while (Date.now() < deadline) {
+    if (await isRunning()) return;
+    await sleep(500);
+  }
+  throw new Error(
+    `[Open Party] Another process is starting the server but it did not become healthy within ${STARTUP_TIMEOUT}ms`
+  );
+}
+async function ensureServerRunning() {
+  if (await isRunning()) return;
+  const { acquired, fd } = acquireStartLock();
+  if (acquired) {
+    try {
+      await spawnAndWait();
+    } finally {
+      releaseStartLock(fd);
+    }
+  } else {
+    await waitForExisting();
   }
 }
 
 // src/client/claude-code/src/mcp-server.ts
 var PARTY_SERVER_URL = process.env.PARTY_SERVER_URL || "http://127.0.0.1:8000";
-var client = new PartyServerClient(PARTY_SERVER_URL);
+var client = new PartyHttpClient(PARTY_SERVER_URL);
 function validateAgent(agentId) {
   const session = readSessionByAgent(agentId);
   if (!session) {
@@ -21283,7 +21354,61 @@ function validateAgent(agentId) {
   }
   return null;
 }
-var server = new McpServer({ name: "open-party", version: "0.1.0" });
+var HEARTBEAT_INTERVAL_MS = parseInt(process.env.HEARTBEAT_INTERVAL_MS || "15000", 10);
+var mySessionId = null;
+var myIdentity = null;
+function resolveSessionId() {
+  const ppid = process.ppid;
+  if (!ppid) return;
+  const claudePath = join3(homedir3(), ".claude", "sessions", `${ppid}.json`);
+  if (!existsSync3(claudePath)) return;
+  let data;
+  try {
+    data = JSON.parse(readFileSync3(claudePath, "utf-8"));
+  } catch {
+    return;
+  }
+  mySessionId = data.sessionId || null;
+}
+function resolveAgentId() {
+  if (myIdentity) return myIdentity;
+  if (!mySessionId) return null;
+  const partyPath = join3(homedir3(), ".open-party", "sessions", `${mySessionId}.json`);
+  if (!existsSync3(partyPath)) return null;
+  let data;
+  try {
+    data = JSON.parse(readFileSync3(partyPath, "utf-8"));
+  } catch {
+    return null;
+  }
+  const agentId = data.agent_id;
+  if (!agentId) return null;
+  myIdentity = { agent_id: agentId, display_name: data.display_name || agentId };
+  return myIdentity;
+}
+function startHeartbeat() {
+  setInterval(async () => {
+    if (!mySessionId) resolveSessionId();
+    const identity = resolveAgentId();
+    if (!identity) return;
+    try {
+      await client.heartbeat(identity.agent_id);
+    } catch (hbErr) {
+      const msg = hbErr.message;
+      if (/not registered/i.test(msg)) {
+        console.warn(`[Open Party MCP] Agent removed by server, re-registering: ${identity.agent_id}`);
+        try {
+          await client.register(identity.agent_id, identity.display_name);
+        } catch (regErr) {
+          console.error("[Open Party MCP] Re-register failed:", regErr);
+        }
+      } else {
+        console.error("[Open Party MCP] Heartbeat failed:", hbErr);
+      }
+    }
+  }, HEARTBEAT_INTERVAL_MS);
+}
+var server = new McpServer({ name: "open-party", version: "0.1.6" });
 server.tool(
   "list_agents",
   "List all agents currently online in the network.",
@@ -21304,6 +21429,7 @@ server.tool(
       lines.push("", "> \u{1F4A1} Use `send_message` to reach any agent above.");
       return { content: [{ type: "text", text: lines.join("\n") }] };
     } catch (e) {
+      console.error("[Open Party MCP] Error listing agents:", e);
       return { content: [{ type: "text", text: `\u274C Error listing agents: ${e.message}` }] };
     }
   }
@@ -21331,6 +21457,7 @@ server.tool(
         return { content: [{ type: "text", text: `\u26A0\uFE0F Send result: ${status}` }] };
       }
     } catch (e) {
+      console.error("[Open Party MCP] Error sending message:", e);
       return { content: [{ type: "text", text: `\u274C Error sending message: ${e.message}` }] };
     }
   }
@@ -21363,6 +21490,7 @@ server.tool(
       lines.push("---", "", "\u{1F4A1} Reply with `send_message` if needed.");
       return { content: [{ type: "text", text: lines.join("\n") }] };
     } catch (e) {
+      console.error("[Open Party MCP] Error checking messages:", e);
       return { content: [{ type: "text", text: `\u274C Error checking messages: ${e.message}` }] };
     }
   }
@@ -21392,17 +21520,20 @@ server.tool(
       lines.push("---");
       return { content: [{ type: "text", text: lines.join("\n") }] };
     } catch (e) {
+      console.error("[Open Party MCP] Error fetching history:", e);
       return { content: [{ type: "text", text: `\u274C Error fetching history: ${e.message}` }] };
     }
   }
 );
 async function main() {
   await ensureServerRunning();
+  resolveSessionId();
+  startHeartbeat();
   const transport = new StdioServerTransport();
   await server.connect(transport);
 }
-main().catch((e) => {
-  console.error(`[Open Party MCP] Fatal: ${e.message}`);
+main().catch((error2) => {
+  console.error("[Open Party MCP] Fatal:", error2);
   process.exit(1);
 });
 //# sourceMappingURL=mcp-server.js.map