@feynmanzhang/open-party 0.1.2 → 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() {
@@ -4940,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", () => {
   });
@@ -4951,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);
   };
@@ -5011,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
@@ -5021,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 });
     });
   });
 }
@@ -5320,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`;
@@ -5423,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();
@@ -5442,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: ");
@@ -5532,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
@@ -5551,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);
   }
 }