@feynmanzhang/open-party 0.1.1 → 0.1.3-beta.0

package/dist/cli/index.js

@@ -201,7 +201,7 @@ function joinTailnet(authKey, timeout = 3e4) {
   const binary = getTailscaleBinary();
   try {
     const output = execWithSudoFallback(
-      [binary, "up", "--authkey", authKey, "--accept-routes"],
+      [binary, "up", "--authkey", authKey],
       timeout
     );
     return { success: true, output: output.trim() };
@@ -3171,7 +3171,7 @@ var init_dist2 = __esm({
             });
             if (!chunk) {
               if (i === 1) {
-                await new Promise((resolve2) => setTimeout(resolve2));
+                await new Promise((resolve3) => setTimeout(resolve3));
                 maxReadCount = 3;
                 continue;
               }
@@ -3410,8 +3410,8 @@ function classifyFetchError(error) {
   if (error instanceof DOMException && error.name === "AbortError") return null;
   return null;
 }
-function sleep(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
+function sleep2(ms) {
+  return new Promise((resolve3) => setTimeout(resolve3, 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({
@@ -3487,7 +3487,7 @@ var init_peer_discovery = __esm({
           } catch (e) {
             console.error("[Discovery] Cycle failed:", e);
           }
-          await sleep(DISCOVERY_INTERVAL * 1e3);
+          await sleep2(DISCOVERY_INTERVAL * 1e3);
         }
       }
       async discoveryCycle() {
@@ -4639,6 +4639,19 @@ body::after{
   fastTimer = setInterval(fastRefresh, 3000);
   fullTimer = setInterval(fullRefresh, 5000);
 
+  // Clipboard click delegation for .cmd elements
+  document.addEventListener('click', function(e) {
+    var cmd = e.target.closest('.cmd');
+    if (!cmd) return;
+    var text = cmd.getAttribute('data-clipboard');
+    if (text) {
+      navigator.clipboard.writeText(text).then(function() {
+        var hint = cmd.querySelector('.copy-hint');
+        if (hint) hint.textContent = 'Copied!';
+      });
+    }
+  });
+
   // Update uptime display every second
   setInterval(function() {
     if (overview && overview.server) {
@@ -4766,7 +4779,7 @@ body::after{
       html += '<div style="color:var(--muted);margin-bottom:6px">Install for ' + info.os + ':</div>';
       info.commands.forEach(function(cmd) {
         const display = info.needs_sudo ? 'sudo ' + cmd : cmd;
-        html += '<div class="cmd" onclick="navigator.clipboard.writeText('' + display.replace(/'/g, "\\'") + '').then(function(){this.querySelector('.copy-hint').textContent='Copied!'}.bind(this))">';
+        html += '<div class="cmd" data-clipboard="' + display.replace(/"/g, '&quot;') + '">';
         html += '<code>' + display + '</code><span class="copy-hint">Click to copy</span></div>';
       });
       if (info.download_url) {
@@ -4927,9 +4940,20 @@ var init_dashboard = __esm({
 
 // src/server/index.ts
 var server_exports = {};
+import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync3, unlinkSync as unlinkSync2 } from "fs";
+import { join as join5, dirname as dirname3 } from "path";
+import { homedir as homedir4 } from "os";
 async function periodicCleanup() {
 }
+function pidFilePath2() {
+  const pluginData = process.env.CLAUDE_PLUGIN_DATA || "";
+  if (pluginData) return join5(pluginData, "server.pid");
+  return join5(homedir4(), ".open-party", "server.pid");
+}
 async function main() {
+  const pidPath = pidFilePath2();
+  mkdirSync3(dirname3(pidPath), { recursive: true });
+  writeFileSync3(pidPath, String(process.pid));
   console.log(`Starting Party Server on port ${PARTY_PORT} (Tailscale IP: ${getSelfIp()})`);
   process.on("SIGHUP", () => {
   });
@@ -4938,6 +4962,10 @@ async function main() {
   const cleanupPromise = periodicCleanup();
   const shutdown = () => {
     console.log("\nShutting down Party Server...");
+    try {
+      unlinkSync2(pidPath);
+    } catch {
+    }
     server.close();
     process.exit(0);
   };
@@ -4998,7 +5026,7 @@ async function installTailscale(platform) {
   const args2 = entry.needsSudo ? [entry.cmd, ...entry.args] : entry.args;
   console.log(`Running: ${cmd} ${args2.join(" ")}
 `);
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     const child = spawn(cmd, args2, {
       stdio: "inherit",
       windowsHide: true
@@ -5008,15 +5036,15 @@ async function installTailscale(platform) {
       if (exited) return;
       exited = true;
       if (code === 0) {
-        resolve2({ success: true, output: "Installation completed." });
+        resolve3({ success: true, output: "Installation completed." });
       } else {
-        resolve2({ success: false, output: `Installation exited with code ${code}` });
+        resolve3({ success: false, output: `Installation exited with code ${code}` });
       }
     });
     child.on("error", (err) => {
       if (exited) return;
       exited = true;
-      resolve2({ success: false, output: err.message });
+      resolve3({ success: false, output: err.message });
     });
   });
 }
@@ -5068,93 +5096,229 @@ function detectAgents() {
 }
 
 // src/cli/agent-installer.ts
-import { existsSync as existsSync3, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { existsSync as existsSync3, readFileSync, writeFileSync, mkdirSync, cpSync, rmSync, readdirSync } from "fs";
 import { join as join3, dirname, resolve } from "path";
 import { homedir as homedir2 } from "os";
-function findPluginDist() {
+function ensureDir(filePath) {
+  const dir = dirname(filePath);
+  if (!existsSync3(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+function readJsonFile(filePath, fallback) {
+  if (!existsSync3(filePath)) return fallback;
+  try {
+    return JSON.parse(readFileSync(filePath, "utf-8"));
+  } catch {
+    return fallback;
+  }
+}
+function writeJsonFile(filePath, data) {
+  ensureDir(filePath);
+  writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n");
+}
+function findPluginDistDir() {
+  const distDir = resolve(import.meta.dirname ?? ".", "..", "claude-code");
+  if (!existsSync3(distDir)) return null;
+  try {
+    const entries = readdirSync(distDir);
+    const dirs = entries.filter((e) => e.startsWith("open-party-"));
+    if (dirs.length === 0) return null;
+    const pluginDir = join3(distDir, dirs[dirs.length - 1]);
+    if (existsSync3(join3(pluginDir, ".claude-plugin", "plugin.json"))) {
+      return pluginDir;
+    }
+  } catch {
+  }
+  return null;
+}
+function findDistJsDir() {
   const possiblePaths = [
-    // When installed globally: <pkg-root>/dist/cli/index.js → <pkg-root>/dist/
-    resolve(import.meta.dirname ?? ".", "..", "party-server.js"),
-    // When running from source: <project>/dist/cli/index.js → <project>/dist/
-    resolve(import.meta.dirname ?? ".", "..", "mcp-server.js")
+    // When installed globally via npm: <pkg-root>/dist/cli/index.js → <pkg-root>/dist/
+    resolve(import.meta.dirname ?? ".", "..")
   ];
   for (const p of possiblePaths) {
-    if (existsSync3(p)) return dirname(p);
+    if (existsSync3(join3(p, "mcp-server.js")) && existsSync3(join3(p, "hook-handler.js"))) {
+      return p;
+    }
   }
   return null;
 }
-function ensureConfigFile(configPath) {
-  const dir = dirname(configPath);
-  if (!existsSync3(dir)) {
-    mkdirSync(dir, { recursive: true });
-  }
-  if (existsSync3(configPath)) {
-    try {
-      const content = readFileSync(configPath, "utf-8");
-      return JSON.parse(content);
-    } catch {
-    }
+function getPluginVersion() {
+  const pluginDir = findPluginDistDir();
+  if (pluginDir) {
+    const manifest2 = readJsonFile(
+      join3(pluginDir, ".claude-plugin", "plugin.json"),
+      {}
+    );
+    if (manifest2.version) return manifest2.version;
   }
-  return { mcpServers: {} };
+  const sourceManifest = resolve(
+    import.meta.dirname ?? ".",
+    "..",
+    "..",
+    "src",
+    "client",
+    "claude-code",
+    ".claude-plugin",
+    "plugin.json"
+  );
+  const manifest = readJsonFile(sourceManifest, {});
+  if (manifest.version) return manifest.version;
+  return "0.1.0";
 }
-function writeConfigFile(configPath, config) {
-  writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+function getMarketplaceDir() {
+  return join3(homedir2(), ".claude", "plugins", "marketplaces", "open-party");
 }
-function getPluginCommand() {
-  const distDir = findPluginDist();
-  if (distDir) {
-    const serverPath = join3(distDir, "mcp-server.js");
-    if (existsSync3(serverPath)) {
-      return { command: "node", args: [serverPath] };
-    }
+function registerMarketplace(version, pluginDir) {
+  const marketplaceDir = getMarketplaceDir();
+  const pluginSourceDir = join3(marketplaceDir, "plugin");
+  const marketplacePluginDir = join3(marketplaceDir, ".claude-plugin");
+  if (!existsSync3(marketplacePluginDir)) {
+    mkdirSync(marketplacePluginDir, { recursive: true });
   }
-  return { command: "npx", args: ["@feynmanzhang/open-party", "mcp"] };
-}
-function getMcpServerConfig() {
-  const cmd = getPluginCommand();
-  if (!cmd) return null;
-  return {
-    type: "stdio",
-    command: cmd.command,
-    args: cmd.args
+  const marketplaceManifest = {
+    name: "open-party",
+    owner: { name: "Feynman Zhang" },
+    metadata: {
+      description: "Decentralized Agent communication network for Claude Code",
+      homepage: "https://github.com/FeynmanZhang/open-party"
+    },
+    plugins: [
+      {
+        name: "open-party",
+        version,
+        source: "./plugin",
+        description: "Decentralized Agent communication network for Claude Code"
+      }
+    ]
+  };
+  writeJsonFile(join3(marketplacePluginDir, "marketplace.json"), marketplaceManifest);
+  if (existsSync3(pluginSourceDir)) {
+    rmSync(pluginSourceDir, { recursive: true });
+  }
+  mkdirSync(pluginSourceDir, { recursive: true });
+  cpSync(pluginDir, pluginSourceDir, { recursive: true });
+  const knownMarketplacesPath = join3(homedir2(), ".claude", "plugins", "known_marketplaces.json");
+  const knownMarketplaces = readJsonFile(knownMarketplacesPath, {});
+  knownMarketplaces["open-party"] = {
+    source: {
+      source: "github",
+      repo: "FeynmanZhang/open-party"
+    },
+    installLocation: marketplaceDir,
+    lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
   };
+  writeJsonFile(knownMarketplacesPath, knownMarketplaces);
 }
 function installClaudeCode() {
-  const configPath = join3(homedir2(), ".claude", "settings.json");
-  const serverConfig = getMcpServerConfig();
-  if (!serverConfig) {
-    return { success: false, error: "Could not locate Open Party plugin files" };
+  const pluginDir = findPluginDistDir();
+  if (!pluginDir) {
+    return {
+      success: false,
+      error: 'Plugin package not found. Run "npm run build:plugin" first, or use "claude --plugin-dir" to install manually.'
+    };
   }
-  const config = ensureConfigFile(configPath);
-  if (!config.mcpServers) config.mcpServers = {};
-  config.mcpServers["open-party"] = serverConfig;
-  writeConfigFile(configPath, config);
-  return { success: true, configPath };
+  const version = getPluginVersion();
+  const installDir = join3(homedir2(), ".claude", "plugins", "cache", "open-party", "open-party", version);
+  if (existsSync3(installDir)) {
+    rmSync(installDir, { recursive: true });
+  }
+  mkdirSync(installDir, { recursive: true });
+  cpSync(pluginDir, installDir, { recursive: true });
+  const mcpServerPath = join3(installDir, "dist", "mcp-server.js");
+  if (!existsSync3(mcpServerPath)) {
+    const distJsDir = findDistJsDir();
+    if (distJsDir) {
+      const targetDist = join3(installDir, "dist");
+      if (!existsSync3(targetDist)) mkdirSync(targetDist, { recursive: true });
+      for (const file of ["mcp-server.js", "hook-handler.js", "party-server.js"]) {
+        const src = join3(distJsDir, file);
+        if (existsSync3(src)) {
+          cpSync(src, join3(targetDist, file));
+        }
+      }
+      for (const file of ["mcp-server.js.map", "hook-handler.js.map", "party-server.js.map"]) {
+        const src = join3(distJsDir, file);
+        if (existsSync3(src)) {
+          cpSync(src, join3(targetDist, file));
+        }
+      }
+    }
+  }
+  const orphanedPath = join3(installDir, "dist", ".orphaned_at");
+  if (existsSync3(orphanedPath)) {
+    rmSync(orphanedPath);
+  }
+  registerMarketplace(version, pluginDir);
+  const pluginsJsonPath = join3(homedir2(), ".claude", "plugins", "installed_plugins.json");
+  const pluginsData = readJsonFile(
+    pluginsJsonPath,
+    { version: 2, plugins: {} }
+  );
+  if (!pluginsData.plugins) pluginsData.plugins = {};
+  if (pluginsData.plugins["open-party@local"]) {
+    delete pluginsData.plugins["open-party@local"];
+  }
+  pluginsData.plugins["open-party@open-party"] = [
+    {
+      scope: "user",
+      installPath: installDir,
+      version,
+      installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  ];
+  writeJsonFile(pluginsJsonPath, pluginsData);
+  const settingsPath = join3(homedir2(), ".claude", "settings.json");
+  const settings = readJsonFile(settingsPath, {});
+  if (settings.mcpServers?.["open-party"]) {
+    delete settings.mcpServers["open-party"];
+    if (Object.keys(settings.mcpServers).length === 0) {
+      delete settings.mcpServers;
+    }
+  }
+  if (!settings.enabledPlugins) {
+    settings.enabledPlugins = {};
+  }
+  if (settings.enabledPlugins["open-party@local"] !== void 0) {
+    delete settings.enabledPlugins["open-party@local"];
+  }
+  settings.enabledPlugins["open-party@open-party"] = true;
+  writeJsonFile(settingsPath, settings);
+  return {
+    success: true,
+    configPath: settingsPath
+  };
 }
 function installCursor() {
   const configPath = join3(homedir2(), ".cursor", "mcp.json");
-  const serverConfig = getMcpServerConfig();
-  if (!serverConfig) {
-    return { success: false, error: "Could not locate Open Party plugin files" };
-  }
-  const config = ensureConfigFile(configPath);
+  const { command: command2, args: args2 } = getPluginCommand();
+  const config = readJsonFile(configPath, {});
   if (!config.mcpServers) config.mcpServers = {};
-  config.mcpServers["open-party"] = serverConfig;
-  writeConfigFile(configPath, config);
+  config.mcpServers["open-party"] = { type: "stdio", command: command2, args: args2 };
+  writeJsonFile(configPath, config);
   return { success: true, configPath };
 }
 function installGeminiCli() {
   const configPath = join3(homedir2(), ".gemini", "settings.json");
-  const serverConfig = getMcpServerConfig();
-  if (!serverConfig) {
-    return { success: false, error: "Could not locate Open Party plugin files" };
-  }
-  const config = ensureConfigFile(configPath);
+  const { command: command2, args: args2 } = getPluginCommand();
+  const config = readJsonFile(configPath, {});
   if (!config.mcpServers) config.mcpServers = {};
-  config.mcpServers["open-party"] = serverConfig;
-  writeConfigFile(configPath, config);
+  config.mcpServers["open-party"] = { type: "stdio", command: command2, args: args2 };
+  writeJsonFile(configPath, config);
   return { success: true, configPath };
 }
+function getPluginCommand() {
+  const distDir = findDistJsDir();
+  if (distDir) {
+    const serverPath = join3(distDir, "mcp-server.js");
+    if (existsSync3(serverPath)) {
+      return { command: "node", args: [serverPath] };
+    }
+  }
+  return { command: "npx", args: ["@feynmanzhang/open-party", "mcp"] };
+}
 async function installPluginToAgent(agentType) {
   switch (agentType) {
     case "claude-code":
@@ -5171,7 +5335,7 @@ async function installPluginToAgent(agentType) {
 // src/cli/setup.ts
 var rl = createInterface({ input: process.stdin, output: process.stdout });
 function prompt(question) {
-  return new Promise((resolve2) => rl.question(question, (answer) => resolve2(answer.trim())));
+  return new Promise((resolve3) => rl.question(question, (answer) => resolve3(answer.trim())));
 }
 function cyan(text) {
   return `\x1B[36m${text}\x1B[0m`;
@@ -5274,10 +5438,10 @@ async function handleInteractiveLogin(binary) {
   console.log(`
 ${cyan("Running interactive login...")}`);
   console.log("A browser window should open. Authenticate in the browser, then return here.\n");
-  const { spawn: spawn2 } = await import("child_process");
-  const child = spawn2(binary, ["login"], { stdio: "inherit" });
-  const exitCode = await new Promise((resolve2) => {
-    child.on("close", resolve2);
+  const { spawn: spawn3 } = await import("child_process");
+  const child = spawn3(binary, ["login"], { stdio: "inherit" });
+  const exitCode = await new Promise((resolve3) => {
+    child.on("close", resolve3);
   });
   resetTailscaleBinaryCache();
   const status = getTailscaleInstallationStatus();
@@ -5293,7 +5457,7 @@ ${yellow("\u26A0\uFE0F  Login may not have completed. Status: " + status.state)}
 }
 async function handleAuthKeyLogin(binary) {
   console.log("");
-  console.log("You can generate an Auth Key at:");
+  console.log("Ask the network creator to generate an Auth Key at:");
   console.log(`${cyan("  https://login.tailscale.com/admin/settings/keys")}
 `);
   const authKey = await prompt("Enter Auth Key: ");
@@ -5352,6 +5516,12 @@ Installing Open Party plugin for ${agent.name}...`);
     const result = await installPluginToAgent(agent.type);
     if (result.success) {
       console.log(`${green("\u2705")} Plugin installed for ${agent.name}${result.configPath ? ` (${result.configPath})` : ""}`);
+      if (result.warning) {
+        console.log(`  ${yellow("\u26A0\uFE0F")} ${result.warning}`);
+      }
+      if (agent.type === "claude-code") {
+        console.log(`  ${bold("Please restart Claude Code")} for changes to take effect.`);
+      }
     } else {
       console.log(`${red("\u274C")} Failed to install for ${agent.name}: ${result.error}`);
     }
@@ -5377,12 +5547,12 @@ async function setupCommand() {
   await stepAgentPlugin();
   console.log(`
 ${bold(cyan("\u{1F680} Starting Party Server..."))}`);
-  const { spawn: spawn2 } = await import("child_process");
-  const { resolve: resolve2, dirname: dirname2 } = await import("path");
-  const { fileURLToPath } = await import("url");
-  const __dirname = dirname2(fileURLToPath(import.meta.url));
-  const serverScript = resolve2(__dirname, "..", "party-server.js");
-  const serverProc = spawn2(process.execPath, [serverScript], {
+  const { spawn: spawn3 } = await import("child_process");
+  const { resolve: resolve3, dirname: dirname4 } = await import("path");
+  const { fileURLToPath: fileURLToPath2 } = await import("url");
+  const __dirname2 = dirname4(fileURLToPath2(import.meta.url));
+  const serverScript = resolve3(__dirname2, "..", "party-server.js");
+  const serverProc = spawn3(process.execPath, [serverScript], {
     detached: true,
     stdio: "ignore",
     windowsHide: true
@@ -5396,28 +5566,334 @@ ${bold(green("\u{1F389} Setup complete!"))}`);
   rl.close();
 }
 
+// src/cli/server-utils.ts
+import { spawn as spawn2, execSync as execSync3 } from "child_process";
+import { existsSync as existsSync4, readFileSync as readFileSync2, writeFileSync as writeFileSync2, unlinkSync, mkdirSync as mkdirSync2, openSync } from "fs";
+import { join as join4, dirname as dirname2, resolve as resolve2 } from "path";
+import { homedir as homedir3 } from "os";
+import { fileURLToPath } from "url";
+var __dirname = dirname2(fileURLToPath(import.meta.url));
+function pidFilePath() {
+  const pluginData = process.env.CLAUDE_PLUGIN_DATA || "";
+  if (pluginData) return join4(pluginData, "server.pid");
+  return join4(homedir3(), ".open-party", "server.pid");
+}
+function logFilePath() {
+  const pluginData = process.env.CLAUDE_PLUGIN_DATA || "";
+  if (pluginData) return join4(pluginData, "server.log");
+  return join4(homedir3(), ".open-party", "server.log");
+}
+function serverScriptPath() {
+  return resolve2(__dirname, "..", "party-server.js");
+}
+function readPid() {
+  const path = pidFilePath();
+  if (!existsSync4(path)) return null;
+  try {
+    return parseInt(readFileSync2(path, "utf-8").trim(), 10);
+  } catch {
+    return null;
+  }
+}
+function writePid(pid) {
+  const path = pidFilePath();
+  const dir = dirname2(path);
+  if (!existsSync4(dir)) mkdirSync2(dir, { recursive: true });
+  writeFileSync2(path, String(pid));
+}
+function removePidFile() {
+  try {
+    unlinkSync(pidFilePath());
+  } catch {
+  }
+}
+function isProcessRunning(pid) {
+  if (process.platform === "win32") {
+    try {
+      const output = execSync3(`tasklist /FI "PID eq ${pid}" /NH`, {
+        encoding: "utf-8",
+        windowsHide: true,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      return output.includes(String(pid));
+    } catch {
+      return false;
+    }
+  }
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function resolvePort() {
+  return parseInt(process.env.PARTY_PORT || "8000", 10);
+}
+async function fetchJson(url, timeoutMs = 2e3) {
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    const resp = await fetch(url, { signal: controller.signal });
+    clearTimeout(timer);
+    if (!resp.ok) return null;
+    return await resp.json();
+  } catch {
+    return null;
+  }
+}
+async function isServerHealthy(port) {
+  const p = port ?? resolvePort();
+  const data = await fetchJson(`http://127.0.0.1:${p}/proxy/health`);
+  return data !== null && data.status === "ok";
+}
+async function getServerHealth(port) {
+  const p = port ?? resolvePort();
+  return fetchJson(`http://127.0.0.1:${p}/proxy/health`);
+}
+async function getServerOverview(port) {
+  const p = port ?? resolvePort();
+  return fetchJson(`http://127.0.0.1:${p}/dashboard/api/overview`, 3e3);
+}
+async function spawnServerInBackground(port) {
+  const script = serverScriptPath();
+  if (!existsSync4(script)) {
+    console.error(`Server script not found: ${script}`);
+    return { pid: 0, ok: false };
+  }
+  const logPath = logFilePath();
+  mkdirSync2(dirname2(logPath), { recursive: true });
+  const logFd = openSync(logPath, "a");
+  const env = { ...process.env, PARTY_PORT: String(port) };
+  const proc = spawn2(process.execPath, [script], {
+    stdio: ["ignore", logFd, logFd],
+    detached: true,
+    windowsHide: true,
+    env
+  });
+  proc.unref();
+  const pid = proc.pid;
+  writePid(pid);
+  proc.on("error", (err) => {
+    console.error(`Failed to start server: ${err.message}`);
+  });
+  return { pid, ok: true };
+}
+async function waitForServerReady(port, timeoutMs = 1e4) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (await isServerHealthy(port)) return true;
+    const pid = readPid();
+    if (pid !== null && !isProcessRunning(pid)) {
+      return false;
+    }
+    await sleep(500);
+  }
+  return false;
+}
+function killServer(pid) {
+  try {
+    if (process.platform === "win32") {
+      execSync3(`taskkill /F /T /PID ${pid}`, { stdio: "ignore", windowsHide: true });
+    } else {
+      process.kill(pid, "SIGTERM");
+    }
+  } catch {
+  }
+}
+function parseStartArgs(args2) {
+  let daemon = false;
+  let port = null;
+  for (let i = 0; i < args2.length; i++) {
+    if (args2[i] === "-d" || args2[i] === "--daemon") {
+      daemon = true;
+    } else if (args2[i] === "-p" || args2[i] === "--port") {
+      const val = args2[++i];
+      if (val) port = parseInt(val, 10);
+    } else if (args2[i].startsWith("--port=")) {
+      port = parseInt(args2[i].split("=")[1], 10);
+    }
+  }
+  return { daemon, port };
+}
+function sleep(ms) {
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
+}
+
 // src/cli/start-server.ts
-async function startServer() {
+async function startServer(args2 = []) {
+  const opts = parseStartArgs(args2);
+  const port = opts.port ?? resolvePort();
+  if (opts.daemon) {
+    await startDaemon(port);
+  } else {
+    await startForeground();
+  }
+}
+async function startForeground() {
+  writePid(process.pid);
+  process.on("exit", () => {
+    removePidFile();
+  });
   await Promise.resolve().then(() => (init_server(), server_exports));
 }
+async function startDaemon(port) {
+  if (await isServerHealthy(port)) {
+    const pid2 = readPid();
+    console.log(`Party Server is already running (PID ${pid2 ?? "unknown"}, port ${port}).`);
+    process.exit(0);
+  }
+  const existingPid = readPid();
+  if (existingPid !== null && !isProcessRunning(existingPid)) {
+    removePidFile();
+  }
+  const { pid, ok } = await spawnServerInBackground(port);
+  if (!ok) {
+    process.exit(1);
+  }
+  console.log(`Starting Party Server in background (PID ${pid})...`);
+  const ready = await waitForServerReady(port);
+  if (ready) {
+    console.log(`Party Server is running on port ${port}.`);
+    console.log(`  Dashboard: http://127.0.0.1:${port}/dashboard`);
+    console.log(`  Logs: ${logFilePath()}`);
+    console.log(`  Use 'open-party stop' to stop the server.`);
+  } else {
+    console.error("Party Server failed to start within timeout.");
+    console.error(`Check logs: ${logFilePath()}`);
+    process.exit(1);
+  }
+}
+
+// src/cli/stop-server.ts
+async function stopServer() {
+  const pid = readPid();
+  if (pid === null) {
+    const port2 = resolvePort();
+    const healthy = await isServerHealthy(port2);
+    if (healthy) {
+      console.log(`No PID file found, but a server is responding on port ${port2}.`);
+      console.log("It may have been started manually. Kill it by port or process name.");
+    } else {
+      console.log("Party Server is not running (no PID file found).");
+    }
+    return;
+  }
+  if (!isProcessRunning(pid)) {
+    console.log(`Stale PID file found (PID ${pid} is not running). Cleaning up.`);
+    removePidFile();
+    return;
+  }
+  console.log(`Stopping Party Server (PID ${pid})...`);
+  killServer(pid);
+  removePidFile();
+  const port = resolvePort();
+  const stillUp = await isServerHealthy(port);
+  if (stillUp) {
+    console.warn(`Process ${pid} was killed, but port ${port} is still responding.`);
+    console.warn("Another process may be using this port.");
+  } else {
+    console.log("Party Server stopped.");
+  }
+}
+
+// src/cli/status.ts
+async function statusCommand() {
+  const port = resolvePort();
+  const pid = readPid();
+  let processAlive = false;
+  if (pid !== null) {
+    processAlive = isProcessRunning(pid);
+  }
+  const healthy = await isServerHealthy(port);
+  if (healthy) {
+    const health = await getServerHealth(port);
+    const overview = await getServerOverview(port);
+    console.log("Party Server is running.");
+    console.log(`  PID:           ${pid ?? "unknown (no PID file)"}`);
+    console.log(`  Port:          ${port}`);
+    console.log(`  Tailscale IP:  ${health?.tailscale_ip ?? "N/A"}`);
+    console.log(`  Hostname:      ${health?.hostname ?? "N/A"}`);
+    if (overview) {
+      const server = overview.server;
+      const agents = overview.agents;
+      if (server?.uptime_seconds != null) {
+        const uptime = server.uptime_seconds;
+        const mins = Math.floor(uptime / 60);
+        const secs = Math.floor(uptime % 60);
+        console.log(`  Uptime:        ${mins}m ${secs}s`);
+      }
+      console.log(`  Local agents:  ${agents?.local_count ?? "N/A"}`);
+      console.log(`  Remote agents: ${agents?.remote_count ?? "N/A"}`);
+    } else {
+      console.log(`  Local agents:  ${health?.agent_count ?? "N/A"}`);
+    }
+    console.log(`  Dashboard:    http://127.0.0.1:${port}/dashboard`);
+  } else if (processAlive && pid !== null) {
+    console.log("Party Server process exists but is not responding on health endpoint.");
+    console.log(`  PID:    ${pid}`);
+    console.log("  The server may be starting up or has crashed.");
+    console.log(`  Logs:   ~/.open-party/server.log`);
+  } else if (pid !== null) {
+    console.log("Party Server is NOT running (stale PID file).");
+    console.log(`  PID file references PID ${pid}, which is not a live process.`);
+    console.log("  Use: open-party start   to start the server.");
+  } else {
+    console.log("Party Server is NOT running.");
+    console.log("  No PID file found.");
+    console.log("  Use: open-party start   to start the server.");
+  }
+}
 
 // src/cli/index.ts
+function showHelp() {
+  console.log(`Usage: open-party <command> [options]
+
+Commands:
+  start     Start the Party Server (default when no command given)
+  stop      Stop the Party Server
+  status    Show server status
+  setup     Interactive setup wizard (Tailscale + agent plugins)
+  help      Show this help message
+
+Options for 'start':
+  -d, --daemon          Run in background (daemon mode)
+  -p, --port <port>     Override port (default: 8000, env: PARTY_PORT)
+
+Examples:
+  open-party                    Start server in foreground
+  open-party start              Start server in foreground
+  open-party start -d           Start server in background
+  open-party start -d -p 9000   Start server in background on port 9000
+  open-party stop               Stop the server
+  open-party status             Check if the server is running`);
+}
 var args = process.argv.slice(2);
 var command = args[0] ?? "start";
+var commandArgs = args.slice(1);
 async function main2() {
   switch (command) {
     case "setup":
       await setupCommand();
       break;
     case "start":
-      await startServer();
+      await startServer(commandArgs);
+      break;
+    case "stop":
+      await stopServer();
+      break;
+    case "status":
+      await statusCommand();
+      break;
+    case "help":
+    case "--help":
+    case "-h":
+      showHelp();
       break;
     default:
-      console.log(`Usage: npx open-party [setup|start]`);
-      console.log("");
-      console.log("Commands:");
-      console.log("  setup   Interactive setup wizard (Tailscale + agent plugins)");
-      console.log("  start   Start the Party Server (default)");
+      console.log(`Unknown command: ${command}
+`);
+      showHelp();
       process.exit(1);
   }
 }