@feynmanzhang/open-party 0.1.5 → 0.1.7

package/README.md

@@ -0,0 +1,138 @@
+<div align="center">
+
+# Open Party
+
+**Decentralized Agent Communication Network for Claude Code**
+
+[![MIT License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+[![Node.js >=20](https://img.shields.io/badge/node-%3E%3D20-green.svg)](https://nodejs.org)
+[![npm version](https://img.shields.io/npm/v/@feynmanzhang/open-party.svg)](https://www.npmjs.com/package/@feynmanzhang/open-party)
+
+Your Claude Code agents finally have a WhatsApp. No central server, no setup headache — just `npm install` and start talking.
+
+[Quick Start](#quick-start) · [CLI Reference](#cli-reference)
+
+</div>
+
+---
+
+## So... what does it do?
+
+You know how you can run multiple Claude Code sessions — maybe one on your laptop, one on a cloud server, one in a container, one on a Raspberry Pi? Open Party lets them talk to each other. Like WhatsApp, but for AI agents.
+
+- **Send messages** between agents on the same machine or across the internet
+- **See who's online** and what they're up to
+- **Get instant push notifications** when someone messages you — your agent can even reply on its own
+- **Works across networks** thanks to [Tailscale](https://tailscale.com) — no public IP or port forwarding needed
+- **Fully decentralized** — every machine runs its own server, no single point of failure
+
+---
+
+## Quick Start
+
+### Prerequisites
+
+- **Node.js** 20 or later
+- **Tailscale** (optional, recommended for cross-network)
+
+### Install & Setup
+
+```bash
+npm install -g @feynmanzhang/open-party
+open-party setup              # Build plugin, install to Claude Code, start server
+```
+
+Restart Claude Code to load the plugin.
+
+### Send Your First Message
+
+```bash
+open-party online              # Go online — register with the Party Server
+open-party agents              # See who's online
+open-party send-message --recipient <id> --content "hello"
+open-party check-messages      # Check unread messages
+open-party offline             # Go offline
+```
+
+Each Claude Code session maps to one agent identity. When you start Claude Code, the agent gets an ID and display name. It stays **offline** until you run `open-party online` — then it becomes visible to other agents.
+
+In Claude Code, just ask your agent: *"go online"*, *"who else is online?"* or *"send a message to agent-x saying hello"*.
+
+### Cross-Machine Setup (Tailscale)
+
+To connect agents across different networks (e.g., your laptop and a remote server):
+
+**1. Install Tailscale on each machine**
+
+```bash
+# macOS
+brew install tailscale
+
+# Linux
+curl -fsSL https://tailscale.com/install.sh | sh
+
+# Windows
+# Download from https://tailscale.com/download/windows
+```
+
+**2. Generate an auth key**
+
+Go to [Tailscale Admin → Keys](https://login.tailscale.com/admin/settings/keys) and create an **auth key** (reuseable recommended). This key lets machines join your network without a browser.
+
+**3. Log in on each machine**
+
+```bash
+open-party login               # Prompts: interactive browser or auth key
+```
+
+**4. Verify connectivity**
+
+```bash
+open-party peers              # Should list the remote machine
+open-party agents             # Should show agents from all machines
+```
+
+> **Real-time push notifications** require the Claude Code channel API (currently in beta):
+> ```bash
+> claude --dangerously-load-development-channels plugin:open-party@open-party
+> ```
+
+---
+
+## CLI Reference
+
+| Command | Description |
+|---------|-------------|
+| `open-party setup` | Build & install plugin, start server |
+| `open-party start` | Start the Party Server |
+| `open-party stop` | Stop the Party Server |
+| `open-party status` | Show server and network status |
+| `open-party online` | Go online — register this agent |
+| `open-party offline` | Go offline — unregister this agent |
+| `open-party agents` | List online agents |
+| `open-party peers` | List discovered remote Party Servers |
+| `open-party send-message` | Send a message to another agent |
+| `open-party check-messages` | Check unread messages (`--history` for full log) |
+| `open-party login` | Log in to Tailscale |
+| `open-party logout` | Log out from Tailscale |
+
+---
+
+## Development
+
+```bash
+git clone https://github.com/feynman1/open-party-CLI.git
+cd open-party
+npm install
+npm run build          # Compile TypeScript
+npm test               # Run all tests (Vitest)
+npm run dev            # Build plugin
+```
+
+For development conventions, see [`docs/client/dev-guide.md`](docs/client/dev-guide.md).
+
+---
+
+## License
+
+[MIT License](LICENSE)

package/dist/claude-code/{open-party-0.1.5 → open-party-0.1.7}/.claude-plugin/plugin.json

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

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

@@ -0,0 +1,6 @@
+{
+  "version": "0.1.7",
+  "git_commit": "c65e078",
+  "build_timestamp": "2026-06-06T14:01:15.770Z",
+  "source_path": "src/client/claude-code/"
+}

package/dist/claude-code/open-party-0.1.7/dist/dispatcher.js

@@ -0,0 +1,187 @@
+#!/usr/bin/env node
+
+
+// src/client/shared/dispatcher.ts
+import { createServer as createHttpServer } from "http";
+import { connect } from "net";
+import { writeFileSync, unlinkSync, mkdirSync, appendFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var DISPATCHER_PORT = parseInt(process.env.DISPATCHER_PORT || "18080", 10);
+var STALE_ROUTE_MS = 9e4;
+var DATA_DIR = join(homedir(), ".open-party");
+var PID_FILE = join(DATA_DIR, "dispatcher.pid");
+var LOG_FILE = join(DATA_DIR, "dispatcher.log");
+function log(msg) {
+  const ts = (/* @__PURE__ */ new Date()).toISOString();
+  const line = `${ts} ${msg}
+`;
+  try {
+    mkdirSync(DATA_DIR, { recursive: true });
+    appendFileSync(LOG_FILE, line);
+  } catch {
+  }
+  console.log(`[Dispatcher] ${msg}`);
+}
+var routes = /* @__PURE__ */ new Map();
+function sanitizeAgentId(agentId) {
+  return agentId.replace(/[^a-zA-Z0-9_-]/g, "-");
+}
+function derivePipePath(agentId) {
+  const safe = sanitizeAgentId(agentId);
+  if (process.platform === "win32") {
+    return `\\\\.\\pipe\\open-party-${safe}`;
+  }
+  return join(DATA_DIR, `pipe-${safe}.sock`);
+}
+function writeToPipe(pipePath, payload) {
+  return new Promise((resolve, reject) => {
+    const client = connect(pipePath, () => {
+      client.write(JSON.stringify(payload));
+      client.end();
+    });
+    client.on("close", () => resolve());
+    client.on("error", (err) => {
+      log(`Pipe write failed: path=${pipePath}, error=${err.message}`);
+      reject(err);
+    });
+    client.setTimeout(5e3);
+    client.on("timeout", () => {
+      client.destroy();
+      reject(new Error("Pipe write timeout"));
+    });
+  });
+}
+function cleanupStaleRoutes() {
+  const now = Date.now();
+  let removed = 0;
+  for (const [id, entry] of routes) {
+    if (now - entry.last_ping > STALE_ROUTE_MS) {
+      routes.delete(id);
+      removed++;
+      log(`Stale route removed: ${id} (idle ${Math.round((now - entry.last_ping) / 1e3)}s)`);
+    }
+  }
+  if (removed > 0) {
+    log(`Cleanup: ${removed} stale routes removed, ${routes.size} active`);
+  }
+}
+setInterval(cleanupStaleRoutes, 3e4);
+var httpServer = createHttpServer(async (req, res) => {
+  try {
+    if (req.method === "GET" && req.url === "/dispatcher/health") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ status: "ok", route_count: routes.size }));
+      return;
+    }
+    if (req.method === "POST" && req.url === "/dispatcher/ping") {
+      const body = await readJsonBody(req);
+      const agentId = body.agent_id;
+      if (!agentId || typeof agentId !== "string") {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Missing or invalid agent_id" }));
+        return;
+      }
+      const pipePath = derivePipePath(agentId);
+      const now = Date.now();
+      const existing = routes.get(agentId);
+      if (existing) {
+        const idleMs = now - existing.last_ping;
+        existing.last_ping = now;
+        log(`Ping: ${agentId} (idle ${Math.round(idleMs / 1e3)}s, ${routes.size} routes active)`);
+      } else {
+        routes.set(agentId, { agent_id: agentId, pipe_path: pipePath, last_ping: now });
+        log(`Route registered: ${agentId} \u2192 ${pipePath}`);
+      }
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ status: "ok" }));
+      return;
+    }
+    if (req.method === "POST" && req.url === "/") {
+      const body = await readJsonBody(req);
+      const recipientId = body.recipient_id;
+      if (!recipientId || typeof recipientId !== "string") {
+        log(`Dispatch rejected: missing recipient_id`);
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Missing recipient_id" }));
+        return;
+      }
+      const route = routes.get(recipientId);
+      if (!route) {
+        log(`Dispatch failed: agent ${recipientId} not found in routes (${routes.size} total)`);
+        res.writeHead(404, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Agent not registered", agent_id: recipientId }));
+        return;
+      }
+      try {
+        await writeToPipe(route.pipe_path, body);
+        log(`Dispatched to ${recipientId} via ${route.pipe_path}`);
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ status: "dispatched" }));
+      } catch (pipeErr) {
+        const errMsg = pipeErr.message;
+        log(`Pipe delivery failed for ${recipientId}: ${errMsg}`);
+        res.writeHead(502, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ status: "error", error: errMsg }));
+      }
+      return;
+    }
+    res.writeHead(404);
+    res.end("Not Found");
+  } catch (err) {
+    const errMsg = err.message;
+    log(`Request error: ${errMsg}`);
+    if (!res.headersSent) {
+      res.writeHead(500, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: errMsg }));
+    }
+  }
+});
+function readJsonBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => {
+      try {
+        resolve(JSON.parse(Buffer.concat(chunks).toString("utf-8")));
+      } catch (parseErr) {
+        const raw = Buffer.concat(chunks).toString("utf-8").slice(0, 200);
+        log(`JSON parse error: ${parseErr.message}, raw=${raw}`);
+        reject(new Error("Invalid JSON body"));
+      }
+    });
+    req.on("error", reject);
+  });
+}
+httpServer.listen(DISPATCHER_PORT, "127.0.0.1", () => {
+  log(`Dispatcher listening on port ${DISPATCHER_PORT}`);
+  try {
+    mkdirSync(DATA_DIR, { recursive: true });
+    writeFileSync(PID_FILE, String(process.pid));
+  } catch (writeErr) {
+    log(`PID file write failed: ${writeErr.message}`);
+  }
+  log(`Ready. PID=${process.pid}, routes=0`);
+});
+httpServer.on("error", (err) => {
+  log(`FATAL: HTTP server error: ${err.message}`);
+  process.exit(1);
+});
+function shutdown() {
+  log("Shutting down...");
+  httpServer.close(() => {
+    log("HTTP server closed.");
+    try {
+      unlinkSync(PID_FILE);
+    } catch {
+    }
+    process.exit(0);
+  });
+  setTimeout(() => process.exit(1), 5e3);
+}
+process.on("SIGINT", shutdown);
+process.on("SIGTERM", shutdown);
+process.on("unhandledRejection", (reason) => {
+  log(`Unhandled rejection: ${reason}`);
+});
+//# sourceMappingURL=dispatcher.js.map

package/dist/claude-code/{open-party-0.1.5 → open-party-0.1.7}/dist/hook-handler.js

@@ -12,6 +12,10 @@ var PartyHttpClient = class {
     this.baseUrl = baseUrl.replace(/\/$/, "");
     this.timeout = timeout;
   }
+  // -- Dashboard --
+  async getOverview() {
+    return this.request("/dashboard/api/overview");
+  }
   async request(path, options = {}) {
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), this.timeout);
@@ -31,10 +35,10 @@ var PartyHttpClient = class {
     }
   }
   // -- Agent lifecycle --
-  async register(agentId, displayName, metadata) {
+  async register(agentId, displayName, metadata, callbackUrl) {
     return this.request("/agent/register", {
       method: "POST",
-      body: JSON.stringify({ agent_id: agentId, display_name: displayName, metadata: metadata ?? {} })
+      body: JSON.stringify({ agent_id: agentId, display_name: displayName, metadata: metadata ?? {}, callback_url: callbackUrl })
     });
   }
   async remove(agentId) {
@@ -44,10 +48,10 @@ var PartyHttpClient = class {
     });
     return result.status === "removed";
   }
-  async heartbeat(agentId) {
+  async heartbeat(agentId, displayName, metadata, callbackUrl) {
     return this.request("/agent/heartbeat", {
       method: "POST",
-      body: JSON.stringify({ agent_id: agentId })
+      body: JSON.stringify({ agent_id: agentId, display_name: displayName, metadata, callback_url: callbackUrl })
     });
   }
   async listAgents() {
@@ -86,18 +90,34 @@ var AGENTS_DIR = join(SESSION_DIR, "agents");
 function ensureDir(dir) {
   if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
 }
-function writeSession(sessionId, agentId, displayName, serverUrl) {
+function writeSession(sessionId, agentId, displayName, serverUrl, sessionKey, online) {
   ensureDir(SESSIONS_DIR);
   ensureDir(AGENTS_DIR);
-  const sessionData = { agent_id: agentId, display_name: displayName, server_url: serverUrl, session_id: sessionId };
+  const sessionData = { agent_id: agentId, display_name: displayName, server_url: serverUrl, session_id: sessionId, session_key: sessionKey, online: online ?? false };
   writeFileSync(join(SESSIONS_DIR, `${sessionId}.json`), JSON.stringify(sessionData));
   writeFileSync(join(AGENTS_DIR, `${agentId}.json`), JSON.stringify({ session_id: sessionId }));
 }
+function updateOnlineStatus(agentId, online) {
+  const session = readSessionByAgent(agentId);
+  if (!session) return;
+  const sessionId = session.session_id;
+  const path = join(SESSIONS_DIR, `${sessionId}.json`);
+  if (!existsSync(path)) return;
+  const data = JSON.parse(readFileSync(path, "utf-8"));
+  data.online = online;
+  writeFileSync(path, JSON.stringify(data));
+}
 function readSession(sessionId) {
   const path = join(SESSIONS_DIR, `${sessionId}.json`);
   if (!existsSync(path)) return void 0;
   return JSON.parse(readFileSync(path, "utf-8"));
 }
+function readSessionByAgent(agentId) {
+  const mappingPath = join(AGENTS_DIR, `${agentId}.json`);
+  if (!existsSync(mappingPath)) return void 0;
+  const mapping = JSON.parse(readFileSync(mappingPath, "utf-8"));
+  return readSession(mapping.session_id);
+}
 
 // src/client/shared/id.ts
 import { randomUUID } from "crypto";
@@ -372,48 +392,36 @@ async function handleSessionStart(sessionId, source) {
   await ensureServerRunning();
   const client = new PartyHttpClient(PARTY_SERVER_URL);
   const existing = readSession(sessionId);
+  const isOnline = existing ? existing.online === "true" || existing.online === true : false;
   if (existing && (source === "clear" || source === "compact" || source === "resume")) {
     const agentId2 = existing.agent_id;
     const displayName2 = existing.display_name || agentId2;
     if (source === "clear") {
-      try {
-        await client.register(agentId2, displayName2, { type: "claude-code" });
-        console.error(`[Open Party] Re-registered as ${agentId2} (${displayName2})`);
-      } catch (error) {
-        console.error("[Open Party] Re-registration failed, will retry on next session:", error);
-      }
-      writeSession(sessionId, agentId2, displayName2, PARTY_SERVER_URL);
+      writeSession(sessionId, agentId2, displayName2, PARTY_SERVER_URL, void 0, false);
     }
-    let agents = [];
+    let agents2 = [];
     let pendingMessages = [];
     try {
-      agents = await client.listAgents();
-      if (source === "resume") {
+      agents2 = await client.listAgents();
+      if (source === "resume" && isOnline) {
         pendingMessages = await client.checkMessages(agentId2);
       }
     } catch (error) {
       console.error("[Open Party] Failed to fetch agent list/messages:", error);
     }
-    outputContext(agentId2, displayName2, agents, pendingMessages);
+    outputContext(agentId2, displayName2, agents2, pendingMessages, isOnline);
     return;
   }
   const agentId = generateAgentId();
   const displayName = generateDisplayName();
+  let agents = [];
   try {
-    const [, agents] = await Promise.all([
-      client.register(agentId, displayName, { type: "claude-code" }),
-      client.listAgents()
-    ]);
-    console.error(`[Open Party] Registered as ${agentId} (${displayName})`);
-    writeSession(sessionId, agentId, displayName, PARTY_SERVER_URL);
-    outputContext(agentId, displayName, agents, []);
-    return;
+    agents = await client.listAgents();
   } catch (error) {
-    console.error("[Open Party] Registration failed:", error);
-    writeSession(sessionId, agentId, displayName, PARTY_SERVER_URL);
-    outputContext(agentId, displayName, [], []);
-    return;
+    console.error("[Open Party] Failed to fetch agent list:", error);
   }
+  writeSession(sessionId, agentId, displayName, PARTY_SERVER_URL, void 0, false);
+  outputContext(agentId, displayName, agents, [], false);
 }
 async function handleSessionEnd(sessionId) {
   const session = readSession(sessionId);
@@ -423,39 +431,11 @@ async function handleSessionEnd(sessionId) {
   const client = new PartyHttpClient(serverUrl);
   try {
     await client.remove(agentId);
-    console.error(`[Open Party] Unregistered ${agentId}`);
-  } catch (error) {
-    console.error("[Open Party] Unregister failed:", error);
-  }
-}
-async function handleUserPromptSubmit(sessionId) {
-  const session = readSession(sessionId);
-  if (!session) return;
-  const agentId = session.agent_id;
-  const serverUrl = session.server_url;
-  const client = new PartyHttpClient(serverUrl);
-  let messages;
-  try {
-    messages = await client.checkMessages(agentId);
+    updateOnlineStatus(agentId, false);
+    console.error(`[Open Party] Offline: ${agentId}`);
   } catch (error) {
-    console.error("[Open Party] Failed to check messages:", error);
-    return;
-  }
-  if (!messages.length) return;
-  const lines = ["## \u{1F4EC} New message(s) from other agents", ""];
-  for (const msg of messages) {
-    const sender = msg.sender_id ?? "unknown";
-    const content = msg.content ?? "";
-    lines.push("---", "", `**From:** \`${sender}\``, "", `> ${content}`, "");
+    console.error("[Open Party] Offline failed:", error);
   }
-  lines.push("---", "", "\u{1F4A1} Respond with `send_message` if needed.");
-  const output = {
-    hookSpecificOutput: {
-      hookEventName: "UserPromptSubmit",
-      additionalContext: lines.join("\n")
-    }
-  };
-  console.log(JSON.stringify(output));
 }
 async function handlePostToolUse() {
   let toolName;
@@ -469,12 +449,17 @@ async function handlePostToolUse() {
   } catch {
   }
   if (!toolName) return;
+  const rawInput = JSON.stringify(toolInput ?? "");
+  const isSendMsg = toolName === "Bash" && /open-party\s+send-message/.test(rawInput);
+  const isCheckMsg = toolName === "Bash" && /open-party\s+check-messages/.test(rawInput);
+  const isListAgents = toolName === "Bash" && /open-party\s+list-agents/.test(rawInput);
+  const isHistory = toolName === "Bash" && /open-party\s+message-history/.test(rawInput);
   let message = "";
-  if (toolName.includes("send_message")) {
+  if (isSendMsg) {
     const recipient = toolInput?.recipient_id ?? "unknown";
     const summary = toolInput?.summary ?? "(no summary)";
     message = `\u2709\uFE0F \u2192 ${recipient}: ${summary}`;
-  } else if (toolName.includes("check_messages")) {
+  } else if (isCheckMsg) {
     if (toolResult?.includes("No new messages")) {
       message = `\u{1F4EC} No new messages`;
     } else {
@@ -494,11 +479,11 @@ async function handlePostToolUse() {
         message = `\u{1F4EC} Messages received`;
       }
     }
-  } else if (toolName.includes("list_agents")) {
+  } else if (isListAgents) {
     const match = toolResult?.match(/Online Agents \((\d+)\)/);
     const count = match ? match[1] : "?";
     message = `\u{1F310} ${count} agent(s) online`;
-  } else if (toolName.includes("message_history")) {
+  } else if (isHistory) {
     const match = toolResult?.match(/Message History \(last (\d+)\)/);
     const count = match ? match[1] : "?";
     message = `\u{1F4DC} Last ${count} messages from history`;
@@ -537,7 +522,7 @@ function formatBanner(displayName, others, pendingCount) {
   }
   return lines.join("\n");
 }
-function outputContext(agentId, displayName, agents, pendingMessages = []) {
+function outputContext(agentId, displayName, agents, pendingMessages = [], isOnline = false) {
   const others = agents.filter((a) => a.agent_id !== agentId);
   const lines = [
     "## Open Party Agent Identity",
@@ -547,7 +532,9 @@ function outputContext(agentId, displayName, agents, pendingMessages = []) {
     "",
     "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.",
     "",
-    "Always use your Agent ID when calling Open Party MCP tools."
+    "Always use your Agent ID when calling Open Party CLI commands (`open-party ...`).",
+    "",
+    isOnline ? "\u{1F4E1} You are **online** and visible to other agents." : "\u{1F4A1} You are **offline**. Run `open-party online` to join the network and become visible."
   ];
   if (others.length > 0) {
     lines.push("");
@@ -557,10 +544,10 @@ function outputContext(agentId, displayName, agents, pendingMessages = []) {
       lines.push(`- **${name}** \`${a.agent_id}\``);
     }
     lines.push("");
-    lines.push("Available tools: `send_message` \xB7 `check_messages` \xB7 `list_agents` \xB7 `message_history`");
+    lines.push("Available CLI commands: `open-party online` \xB7 `open-party offline` \xB7 `open-party agents` \xB7 `open-party send-message` \xB7 `open-party check-messages`");
   } else {
     lines.push("");
-    lines.push("No other agents online right now. Use `list_agents()` to check later.");
+    lines.push("No other agents online right now. Use `open-party list-agents` to check later.");
   }
   if (pendingMessages.length > 0) {
     lines.push("");
@@ -571,11 +558,11 @@ function outputContext(agentId, displayName, agents, pendingMessages = []) {
       const content = msg.content ?? "";
       lines.push(`- **From \`${sender}\`:** ${content}`);
     }
-    lines.push("Respond with `send_message` if needed.");
+    lines.push("Respond with `open-party send-message` if needed.");
   }
   lines.push("");
   lines.push(
-    '**Display note:** When you call Open Party tools, summarize the interaction naturally in your response rather than quoting raw tool output. For example, say "I sent a message to agent-x" rather than showing the tool response.'
+    '**Display note:** When you call Open Party CLI commands, summarize the interaction naturally in your response rather than quoting raw tool output. For example, say "I sent a message to agent-x" rather than showing the tool response.'
   );
   const output = {
     hookSpecificOutput: {
@@ -588,7 +575,7 @@ function outputContext(agentId, displayName, agents, pendingMessages = []) {
 }
 async function main() {
   if (process.argv.length < 2) {
-    console.error("Usage: hook-handler.js <session_start|session_end|user_prompt_submit>");
+    console.error("Usage: hook-handler.js <session_start|session_end|post_tool_use>");
     process.exit(1);
   }
   const event = process.argv[2];
@@ -605,8 +592,6 @@ async function main() {
     await handleSessionStart(sessionId, source || "startup");
   } else if (event === "session_end") {
     await handleSessionEnd(sessionId);
-  } else if (event === "user_prompt_submit") {
-    await handleUserPromptSubmit(sessionId);
   } else if (event === "post_tool_use") {
     await handlePostToolUse();
   } else {