@feynmanzhang/open-party 0.1.6 → 0.1.7

package/dist/openclaw/open-party-0.1.5/dist/index.js

@@ -1,550 +0,0 @@
-#!/usr/bin/env node
-
-
-// src/client/shared/client.ts
-var PartyHttpClient = class {
-  baseUrl;
-  timeout;
-  constructor(baseUrl = "http://127.0.0.1:8000", timeout = 5e3) {
-    this.baseUrl = baseUrl.replace(/\/$/, "");
-    this.timeout = timeout;
-  }
-  async request(path, options = {}) {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), this.timeout);
-    try {
-      const resp = await fetch(`${this.baseUrl}${path}`, {
-        ...options,
-        signal: controller.signal,
-        headers: {
-          "Content-Type": "application/json",
-          ...options.headers
-        }
-      });
-      if (!resp.ok) throw new Error(`HTTP ${resp.status}: ${resp.statusText}`);
-      return resp.json();
-    } finally {
-      clearTimeout(timer);
-    }
-  }
-  // -- Agent lifecycle --
-  async register(agentId, displayName, metadata) {
-    return this.request("/agent/register", {
-      method: "POST",
-      body: JSON.stringify({ agent_id: agentId, display_name: displayName, metadata: metadata ?? {} })
-    });
-  }
-  async remove(agentId) {
-    const result = await this.request("/agent/remove", {
-      method: "POST",
-      body: JSON.stringify({ agent_id: agentId })
-    });
-    return result.status === "removed";
-  }
-  async heartbeat(agentId) {
-    return this.request("/agent/heartbeat", {
-      method: "POST",
-      body: JSON.stringify({ agent_id: agentId })
-    });
-  }
-  async listAgents() {
-    const result = await this.request("/agent/list");
-    return result.agents ?? [];
-  }
-  // -- Messaging --
-  async sendMessage(senderId, recipientId, content, summary) {
-    return this.request("/agent/send", {
-      method: "POST",
-      body: JSON.stringify({ sender_id: senderId, recipient_id: recipientId, content, summary })
-    });
-  }
-  async checkMessages(agentId) {
-    const result = await this.request(`/agent/messages/${agentId}`);
-    return result.messages ?? [];
-  }
-  /** Get message history for an agent. */
-  async getMessageHistory(agentId, limit = 20) {
-    const result = await this.request(`/agent/history/${agentId}?limit=${limit}`);
-    return result.history ?? [];
-  }
-  // -- Proxy --
-  async health() {
-    return this.request("/proxy/health");
-  }
-};
-
-// src/client/shared/server-manager.ts
-import { spawn, execSync } from "child_process";
-import {
-  existsSync,
-  readFileSync,
-  writeFileSync,
-  unlinkSync,
-  mkdirSync,
-  openSync,
-  closeSync
-} from "fs";
-import { join, resolve, dirname } from "path";
-import { homedir } from "os";
-import { fileURLToPath } from "url";
-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 pidFileDir() {
-  const pluginData = process.env.CLAUDE_PLUGIN_DATA || "";
-  if (pluginData) return pluginData;
-  return join(homedir(), ".open-party");
-}
-function pidFilePath() {
-  return join(pidFileDir(), "server.pid");
-}
-function logFilePath() {
-  return join(pidFileDir(), "server.log");
-}
-function lockFilePath() {
-  return join(pidFileDir(), "starting.lock");
-}
-function pluginRoot() {
-  if (process.env.CLAUDE_PLUGIN_ROOT) return process.env.CLAUDE_PLUGIN_ROOT;
-  const fromHere = resolve(__dirname, "..");
-  if (existsSync(join(fromHere, "dist", "party-server.js"))) {
-    return fromHere;
-  }
-  if (existsSync(join(fromHere, "party-server.js"))) {
-    return fromHere;
-  }
-  return resolve(__dirname, "..");
-}
-async function isRunning() {
-  try {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), 2e3);
-    const resp = await fetch(HEALTH_URL, { signal: controller.signal });
-    clearTimeout(timer);
-    return resp.status === 200;
-  } catch {
-    return false;
-  }
-}
-function writePid(pid) {
-  const path = pidFilePath();
-  const dir = dirname(path);
-  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-  writeFileSync(path, String(pid));
-}
-async function sleep(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
-}
-function acquireStartLock() {
-  const lockPath = lockFilePath();
-  try {
-    const fd = openSync(lockPath, "wx");
-    writeFileSync(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 {
-    unlinkSync(lockFilePath());
-  } catch {
-  }
-}
-async function spawnAndWait() {
-  const serverScript = join(pluginRoot(), "dist", "party-server.js");
-  if (!existsSync(serverScript)) {
-    throw new Error(`[Open Party] Server script not found: ${serverScript}`);
-  }
-  const logPath = logFilePath();
-  mkdirSync(dirname(logPath), { recursive: true });
-  const logFd = openSync(logPath, "a");
-  const proc = spawn(process.execPath, [serverScript], {
-    stdio: ["ignore", logFd, logFd],
-    detached: true,
-    windowsHide: true
-  });
-  proc.unref();
-  writePid(proc.pid);
-  proc.on("error", (err) => {
-    console.error(`[Open Party] Failed to start server: ${err.message}`);
-  });
-  const deadline = Date.now() + STARTUP_TIMEOUT;
-  while (Date.now() < deadline) {
-    if (await isRunning()) return;
-    await sleep(500);
-  }
-  let alive = false;
-  try {
-    process.kill(proc.pid, 0);
-    alive = true;
-  } catch {
-  }
-  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/shared/session-store.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, readdirSync, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "fs";
-import { join as join2 } from "path";
-import { homedir as homedir2 } from "os";
-var SESSION_DIR = join2(homedir2(), ".open-party");
-var SESSIONS_DIR = join2(SESSION_DIR, "sessions");
-var AGENTS_DIR = join2(SESSION_DIR, "agents");
-function ensureDir(dir) {
-  if (!existsSync2(dir)) mkdirSync2(dir, { recursive: true });
-}
-function writeSession(sessionId, agentId, displayName, serverUrl) {
-  ensureDir(SESSIONS_DIR);
-  ensureDir(AGENTS_DIR);
-  const sessionData = { agent_id: agentId, display_name: displayName, server_url: serverUrl, session_id: sessionId };
-  writeFileSync2(join2(SESSIONS_DIR, `${sessionId}.json`), JSON.stringify(sessionData));
-  writeFileSync2(join2(AGENTS_DIR, `${agentId}.json`), JSON.stringify({ session_id: sessionId }));
-}
-function readSession(sessionId) {
-  const path = join2(SESSIONS_DIR, `${sessionId}.json`);
-  if (!existsSync2(path)) return void 0;
-  return JSON.parse(readFileSync2(path, "utf-8"));
-}
-function clearSession(sessionId) {
-  const sessionPath = join2(SESSIONS_DIR, `${sessionId}.json`);
-  if (!existsSync2(sessionPath)) return;
-  const sessionData = JSON.parse(readFileSync2(sessionPath, "utf-8"));
-  const agentId = sessionData.agent_id;
-  try {
-    unlinkSync2(sessionPath);
-  } catch {
-  }
-  if (agentId) {
-    try {
-      unlinkSync2(join2(AGENTS_DIR, `${agentId}.json`));
-    } catch {
-    }
-  }
-}
-function findAnySession() {
-  if (!existsSync2(SESSIONS_DIR)) return void 0;
-  const files = readdirSync(SESSIONS_DIR).filter((f) => f.endsWith(".json"));
-  if (files.length === 0) return void 0;
-  return readSession(files[0].slice(0, -5));
-}
-
-// src/client/shared/id.ts
-import { randomUUID } from "crypto";
-function generateAgentId() {
-  return `agent-${randomUUID().slice(0, 12)}`;
-}
-function generateDisplayName() {
-  const adjectives = [
-    "swift",
-    "calm",
-    "bold",
-    "keen",
-    "warm",
-    "bright",
-    "clever",
-    "noble",
-    "agile",
-    "brave"
-  ];
-  const nouns = [
-    "falcon",
-    "river",
-    "storm",
-    "raven",
-    "tiger",
-    "canyon",
-    "spark",
-    "cedar",
-    "fox",
-    "wolf"
-  ];
-  const adj = adjectives[Math.floor(Math.random() * adjectives.length)];
-  const noun = nouns[Math.floor(Math.random() * nouns.length)];
-  const num = Math.floor(Math.random() * 100);
-  return `${adj}-${noun}-${num}`;
-}
-
-// src/client/openclaw/src/index.ts
-var PARTY_SERVER_URL = process.env.PARTY_SERVER_URL || "http://127.0.0.1:8000";
-var cachedBaseContext;
-var currentIdentity = null;
-var hbAbortController = null;
-var hbLoopPromise = null;
-function findSessionForCommand(_ctx) {
-  return findAnySession();
-}
-function openPartyPlugin(api) {
-  const client = new PartyHttpClient(PARTY_SERVER_URL);
-  api.registerService({
-    id: "open-party-heartbeat",
-    start: async (ctx) => {
-      if (hbAbortController) {
-        hbAbortController.abort();
-        if (hbLoopPromise) {
-          await hbLoopPromise;
-        }
-      }
-      const hbInterval = ctx.config.heartbeatInterval || parseInt(process.env.HEARTBEAT_INTERVAL_MS || "15000", 10);
-      ctx.logger.info(`[Open Party] Heartbeat service starting (interval: ${hbInterval}ms)`);
-      hbAbortController = new AbortController();
-      const signal = hbAbortController.signal;
-      hbLoopPromise = (async () => {
-        while (!signal.aborted) {
-          try {
-            await new Promise((resolve2, reject) => {
-              const timer = setTimeout(resolve2, hbInterval);
-              signal.addEventListener("abort", () => {
-                clearTimeout(timer);
-                reject(new Error("aborted"));
-              }, { once: true });
-              timer.unref();
-            });
-            if (signal.aborted) break;
-            if (!currentIdentity) continue;
-            await client.heartbeat(currentIdentity.agent_id);
-          } catch (err) {
-            if (signal.aborted) break;
-            const msg = err instanceof Error ? err.message : String(err);
-            if (/not registered/i.test(msg) && currentIdentity) {
-              ctx.logger.warn(`[Open Party] Agent removed by server, re-registering: ${currentIdentity.agent_id}`);
-              try {
-                await client.register(currentIdentity.agent_id, currentIdentity.display_name, { type: "openclaw" });
-              } catch (regErr) {
-                ctx.logger.error(`[Open Party] Re-register failed: ${regErr instanceof Error ? regErr.message : regErr}`);
-              }
-            } else {
-              ctx.logger.error(`[Open Party] Heartbeat error: ${msg}`);
-            }
-          }
-        }
-      })();
-    },
-    stop: async (ctx) => {
-      if (hbAbortController) {
-        hbAbortController.abort();
-        hbAbortController = null;
-      }
-      if (hbLoopPromise) {
-        try {
-          await hbLoopPromise;
-        } catch {
-        }
-        hbLoopPromise = null;
-      }
-      ctx.logger.info("[Open Party] Heartbeat service stopped");
-    }
-  });
-  api.on("session_start", async (event, _ctx) => {
-    const sessionId = event.sessionId;
-    await ensureServerRunning();
-    const existing = readSession(sessionId);
-    let agentId;
-    let displayName;
-    if (existing) {
-      agentId = existing.agent_id;
-      displayName = existing.display_name;
-      api.logger.info(`[Open Party] Resumed as ${agentId} (${displayName})`);
-    } else {
-      agentId = generateAgentId();
-      displayName = generateDisplayName();
-    }
-    try {
-      const [, agents] = await Promise.all([
-        client.register(agentId, displayName, { type: "openclaw" }),
-        client.listAgents()
-      ]);
-      api.logger.info(`[Open Party] Registered as ${agentId} (${displayName})`);
-      writeSession(sessionId, agentId, displayName, PARTY_SERVER_URL);
-      const others = agents.filter((a) => a.agent_id !== agentId);
-      const lines = [];
-      lines.push("## Open Party Agent Identity", "");
-      lines.push(`Your Agent ID: **${agentId}**`);
-      lines.push(`Your Display Name: **${displayName}**`, "");
-      lines.push(
-        "You are connected to the Open Party network as an autonomous agent. Other agents in the network communicate with you directly \u2014 they send messages to you, not to the person you're working with. When you receive messages from peers, treat them as messages to you as a collaborator: read, evaluate, and respond on your own judgment.",
-        ""
-      );
-      lines.push("Always use your Agent ID when calling Open Party tools.", "");
-      if (others.length > 0) {
-        lines.push(`**${others.length}** other agent(s) online:`);
-        for (const a of others) {
-          const name = a.display_name || a.agent_id;
-          lines.push(`- **${name}** \`${a.agent_id}\``);
-        }
-        lines.push("");
-        lines.push("Available commands: `/send <agent_id> <message>` \xB7 `/list_agents` \xB7 `/check_messages`");
-      } else {
-        lines.push("No other agents online right now. Use `/list_agents` to check later.");
-      }
-      cachedBaseContext = lines.join("\n");
-      currentIdentity = { agent_id: agentId, display_name: displayName };
-    } catch (error) {
-      api.logger.error(`[Open Party] Session start failed: ${error instanceof Error ? error.message : String(error)}`);
-    }
-  });
-  api.on("session_end", async (event, _ctx) => {
-    const sessionId = event.sessionId;
-    const session = readSession(sessionId);
-    if (!session) return;
-    currentIdentity = null;
-    try {
-      await client.remove(session.agent_id);
-      api.logger.info(`[Open Party] Unregistered ${session.agent_id}`);
-    } catch (error) {
-      api.logger.error(`[Open Party] Unregister failed: ${error instanceof Error ? error.message : String(error)}`);
-    }
-    clearSession(sessionId);
-  });
-  api.on("before_prompt_build", async (_event, ctx) => {
-    const sessionId = ctx.context?.sessionId || ctx.sessionKey || "default";
-    const session = readSession(sessionId);
-    if (!session || !cachedBaseContext) return;
-    let messages = [];
-    try {
-      messages = await client.checkMessages(session.agent_id);
-    } catch (error) {
-      api.logger.error(`[Open Party] Failed to check messages: ${error instanceof Error ? error.message : String(error)}`);
-    }
-    const lines = [cachedBaseContext];
-    if (messages.length > 0) {
-      lines.push("", `## \u{1F4EC} Unread Messages (${messages.length})`);
-      for (const msg of messages) {
-        const sender = msg.sender_id ?? "unknown";
-        const content = msg.content ?? "";
-        lines.push(`- **From \`${sender}\`:** ${content}`);
-      }
-      lines.push("Respond with `/send` if needed.");
-    }
-    return { appendSystemContext: lines.join("\n") };
-  });
-  api.on("message_received", async (_event, _ctx) => {
-  });
-  api.registerCommand({
-    name: "list_agents",
-    description: "List all agents currently online in the Open Party network.",
-    handler: async (_ctx) => {
-      let agents;
-      try {
-        agents = await client.listAgents();
-      } catch (error) {
-        return { text: `\u274C Error listing agents: ${error instanceof Error ? error.message : String(error)}` };
-      }
-      if (!agents.length) {
-        return { text: "No agents currently online. Try again later with `/list_agents`." };
-      }
-      const lines = [`## \u{1F310} Online Agents (${agents.length})`, "", "| # | Name | Agent ID |", "|---|------|----------|"];
-      for (let i = 0; i < agents.length; i++) {
-        const a = agents[i];
-        const name = a.display_name || a.agent_id;
-        const id = a.agent_id;
-        lines.push(`| ${i + 1} | **${name}** | \`${id}\` |`);
-      }
-      lines.push("", "> \u{1F4A1} Use `/send <agent_id> <message>` to reach any agent above.");
-      return { text: lines.join("\n") };
-    }
-  });
-  api.registerCommand({
-    name: "send",
-    description: "Send a message to another agent in the Open Party network.",
-    acceptsArgs: true,
-    handler: async (ctx) => {
-      const session = findSessionForCommand(ctx);
-      if (!session) {
-        return { text: "\u274C No active session. Your session may have expired." };
-      }
-      const args = (ctx.args || "").trim();
-      const firstSpace = args.indexOf(" ");
-      if (firstSpace === -1) {
-        return { text: "Usage: `/send <agent_id> <message>`" };
-      }
-      const recipientId = args.slice(0, firstSpace);
-      const content = args.slice(firstSpace + 1);
-      try {
-        const result = await client.sendMessage(session.agent_id, recipientId, content);
-        const status = result.status;
-        if (status === "delivered_locally" || status === "forwarded") {
-          return { text: `\u{1F4E4} **Sent** to **${recipientId}**` };
-        } else if (status === "agent_not_found") {
-          return { text: `\u26A0\uFE0F Agent \`${recipientId}\` not found. Use \`/list_agents\` to see who's online.` };
-        } else {
-          return { text: `\u26A0\uFE0F Send result: ${status}` };
-        }
-      } catch (error) {
-        return { text: `\u274C Error sending message: ${error instanceof Error ? error.message : String(error)}` };
-      }
-    }
-  });
-  api.registerCommand({
-    name: "check_messages",
-    description: "Check for messages from other agents in the Open Party network.",
-    handler: async (ctx) => {
-      const session = findSessionForCommand(ctx);
-      if (!session) {
-        return { text: "\u274C No active session. Your session may have expired." };
-      }
-      try {
-        const messages = await client.checkMessages(session.agent_id);
-        if (!messages.length) {
-          return { text: "\u{1F4EC} No new messages." };
-        }
-        const lines = [`## \u{1F4EC} Messages (${messages.length})`, ""];
-        for (const msg of messages) {
-          const sender = msg.sender_id ?? "unknown";
-          const msgSummary = msg.summary ?? void 0;
-          const msgContent = msg.content ?? "";
-          lines.push("---", "", `**From:** \`${sender}\``, "");
-          if (msgSummary) {
-            lines.push(`**Summary:** ${msgSummary}`, "");
-          }
-          lines.push(`> ${msgContent}`, "");
-        }
-        lines.push("---", "", "\u{1F4A1} Reply with `/send` if needed.");
-        return { text: lines.join("\n") };
-      } catch (error) {
-        return { text: `\u274C Error checking messages: ${error instanceof Error ? error.message : String(error)}` };
-      }
-    }
-  });
-  api.logger.info(`[Open Party] OpenClaw plugin loaded \u2014 server: ${PARTY_SERVER_URL}`);
-}
-export {
-  openPartyPlugin as default
-};
-//# sourceMappingURL=index.js.map