diffprism 0.14.0 → 0.16.0

package/dist/bin.js

@@ -1,9 +1,12 @@
 #!/usr/bin/env node
 import {
+  isServerAlive,
+  readServerFile,
   readWatchFile,
+  startGlobalServer,
   startReview,
   startWatch
-} from "./chunk-TVXIMP3G.js";
+} from "./chunk-4WN4FIY4.js";
 
 // cli/src/index.ts
 import { Command } from "commander";
@@ -490,9 +493,92 @@ async function notifyStop() {
   process.exit(0);
 }
 
+// cli/src/commands/server.ts
+async function server(flags) {
+  const existing = await isServerAlive();
+  if (existing) {
+    console.log(`DiffPrism server is already running on port ${existing.httpPort} (PID ${existing.pid})`);
+    console.log(`Use 'diffprism server stop' to stop it first.`);
+    process.exit(1);
+    return;
+  }
+  const httpPort = flags.port ? parseInt(flags.port, 10) : void 0;
+  const wsPort = flags.wsPort ? parseInt(flags.wsPort, 10) : void 0;
+  try {
+    const handle = await startGlobalServer({
+      httpPort,
+      wsPort,
+      dev: flags.dev
+    });
+    const shutdown = async () => {
+      console.log("\nStopping server...");
+      await handle.stop();
+      process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    await new Promise(() => {
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`Error starting server: ${message}`);
+    process.exit(1);
+  }
+}
+async function serverStatus() {
+  const info = await isServerAlive();
+  if (!info) {
+    console.log("No DiffPrism server is running.");
+    process.exit(1);
+    return;
+  }
+  try {
+    const response = await fetch(`http://localhost:${info.httpPort}/api/status`, {
+      signal: AbortSignal.timeout(2e3)
+    });
+    const status = await response.json();
+    console.log(`DiffPrism Server`);
+    console.log(`  API:      http://localhost:${info.httpPort}`);
+    console.log(`  WS:       ws://localhost:${info.wsPort}`);
+    console.log(`  PID:      ${status.pid}`);
+    console.log(`  Sessions: ${status.sessions}`);
+    console.log(`  Uptime:   ${Math.floor(status.uptime)}s`);
+    if (status.sessions > 0) {
+      const sessionsResponse = await fetch(
+        `http://localhost:${info.httpPort}/api/reviews`,
+        { signal: AbortSignal.timeout(2e3) }
+      );
+      const { sessions } = await sessionsResponse.json();
+      console.log(`
+  Active Sessions:`);
+      for (const s of sessions) {
+        const label = s.title ?? s.branch ?? s.projectPath;
+        console.log(`    ${s.id} \u2014 ${label} (${s.status}, ${s.fileCount} files, +${s.additions}/-${s.deletions})`);
+      }
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`Error checking server status: ${message}`);
+    process.exit(1);
+  }
+}
+async function serverStop() {
+  const info = readServerFile();
+  if (!info) {
+    console.log("No DiffPrism server is running.");
+    return;
+  }
+  try {
+    process.kill(info.pid, "SIGTERM");
+    console.log(`Sent stop signal to DiffPrism server (PID ${info.pid}).`);
+  } catch {
+    console.log(`Server process (PID ${info.pid}) is no longer running. Cleaning up.`);
+  }
+}
+
 // cli/src/index.ts
 var program = new Command();
-program.name("diffprism").description("Local-first code review tool for agent-generated changes").version(true ? "0.14.0" : "0.0.0-dev");
+program.name("diffprism").description("Local-first code review tool for agent-generated changes").version(true ? "0.16.0" : "0.0.0-dev");
 program.command("review [ref]").description("Open a browser-based diff review").option("--staged", "Review staged changes").option("--unstaged", "Review unstaged changes").option("-t, --title <title>", "Review title").option("--dev", "Use Vite dev server with HMR instead of static files").action(review);
 program.command("start [ref]").description("Set up DiffPrism and start watching for changes").option("--staged", "Watch staged changes").option("--unstaged", "Watch unstaged changes").option("-t, --title <title>", "Review title").option("--interval <ms>", "Poll interval in milliseconds (default: 1000)").option("--dev", "Use Vite dev server with HMR instead of static files").option("--global", "Install skill globally (~/.claude/skills/)").option("--force", "Overwrite existing configuration files").action(start);
 program.command("watch [ref]").description("Start a persistent diff watcher with live-updating browser UI").option("--staged", "Watch staged changes").option("--unstaged", "Watch unstaged changes").option("-t, --title <title>", "Review title").option("--interval <ms>", "Poll interval in milliseconds (default: 1000)").option("--dev", "Use Vite dev server with HMR instead of static files").action(watch);
@@ -501,4 +587,7 @@ program.command("serve").description("Start the MCP server for Claude Code integ
 program.command("setup").description("Configure DiffPrism for Claude Code integration").option("--global", "Install skill globally (~/.claude/skills/)").option("--force", "Overwrite existing configuration files").action((flags) => {
   setup(flags);
 });
+var serverCmd = program.command("server").description("Start the global DiffPrism server for multi-session reviews").option("-p, --port <port>", "HTTP API port (default: 24680)").option("--ws-port <port>", "WebSocket port (default: 24681)").option("--dev", "Use Vite dev server with HMR instead of static files").action(server);
+serverCmd.command("status").description("Check if the global server is running and list active sessions").action(serverStatus);
+serverCmd.command("stop").description("Stop the running global server").action(serverStop);
 program.parse();

package/dist/{chunk-TVXIMP3G.js → chunk-4WN4FIY4.js}

@@ -1,7 +1,3 @@
-// packages/core/src/pipeline.ts
-import getPort from "get-port";
-import open from "open";
-
 // packages/git/src/local.ts
 import { execSync } from "child_process";
 import { readFileSync } from "fs";
@@ -537,15 +533,15 @@ var CONFIG_PATTERNS = [
   /vite\.config/,
   /vitest\.config/
 ];
-function isTestFile(path5) {
-  return TEST_PATTERNS.some((re) => re.test(path5));
+function isTestFile(path6) {
+  return TEST_PATTERNS.some((re) => re.test(path6));
 }
-function isNonCodeFile(path5) {
-  const ext = path5.slice(path5.lastIndexOf("."));
+function isNonCodeFile(path6) {
+  const ext = path6.slice(path6.lastIndexOf("."));
   return NON_CODE_EXTENSIONS.has(ext);
 }
-function isConfigFile(path5) {
-  return CONFIG_PATTERNS.some((re) => re.test(path5));
+function isConfigFile(path6) {
+  return CONFIG_PATTERNS.some((re) => re.test(path6));
 }
 function detectTestCoverageGaps(files) {
   const filePaths = new Set(files.map((f) => f.path));
@@ -717,17 +713,21 @@ function analyze(diffSet) {
   };
 }
 
+// packages/core/src/pipeline.ts
+import getPort from "get-port";
+import open from "open";
+
 // packages/core/src/ws-bridge.ts
 import { WebSocketServer, WebSocket } from "ws";
 function createWsBridge(port) {
-  const wss = new WebSocketServer({ port });
+  const wss2 = new WebSocketServer({ port });
   let client = null;
   let resultResolve = null;
   let resultReject = null;
   let pendingInit = null;
   let initPayload = null;
   let closeTimer = null;
-  wss.on("connection", (ws) => {
+  wss2.on("connection", (ws) => {
     if (closeTimer) {
       clearTimeout(closeTimer);
       closeTimer = null;
@@ -787,10 +787,10 @@ function createWsBridge(port) {
       });
     },
     close() {
-      for (const ws of wss.clients) {
+      for (const ws of wss2.clients) {
         ws.close();
       }
-      wss.close();
+      wss2.close();
     }
   };
 }
@@ -1061,6 +1061,76 @@ function consumeReviewResult(cwd) {
   }
 }
 
+// packages/core/src/server-file.ts
+import fs3 from "fs";
+import path5 from "path";
+import os from "os";
+function serverDir() {
+  return path5.join(os.homedir(), ".diffprism");
+}
+function serverFilePath() {
+  return path5.join(serverDir(), "server.json");
+}
+function isPidAlive2(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function writeServerFile(info) {
+  const dir = serverDir();
+  if (!fs3.existsSync(dir)) {
+    fs3.mkdirSync(dir, { recursive: true });
+  }
+  fs3.writeFileSync(serverFilePath(), JSON.stringify(info, null, 2) + "\n");
+}
+function readServerFile() {
+  const filePath = serverFilePath();
+  if (!fs3.existsSync(filePath)) {
+    return null;
+  }
+  try {
+    const raw = fs3.readFileSync(filePath, "utf-8");
+    const info = JSON.parse(raw);
+    if (!isPidAlive2(info.pid)) {
+      fs3.unlinkSync(filePath);
+      return null;
+    }
+    return info;
+  } catch {
+    return null;
+  }
+}
+function removeServerFile() {
+  try {
+    const filePath = serverFilePath();
+    if (fs3.existsSync(filePath)) {
+      fs3.unlinkSync(filePath);
+    }
+  } catch {
+  }
+}
+async function isServerAlive() {
+  const info = readServerFile();
+  if (!info) {
+    return null;
+  }
+  try {
+    const response = await fetch(`http://localhost:${info.httpPort}/api/status`, {
+      signal: AbortSignal.timeout(2e3)
+    });
+    if (response.ok) {
+      return info;
+    }
+    return null;
+  } catch {
+    removeServerFile();
+    return null;
+  }
+}
+
 // packages/core/src/watch.ts
 import { createHash } from "crypto";
 import getPort2 from "get-port";
@@ -1117,13 +1187,13 @@ function createWatchBridge(port, callbacks) {
     res.writeHead(404);
     res.end("Not found");
   });
-  const wss = new WebSocketServer2({ server: httpServer });
+  const wss2 = new WebSocketServer2({ server: httpServer });
   function sendToClient(msg) {
     if (client && client.readyState === WebSocket2.OPEN) {
       client.send(JSON.stringify(msg));
     }
   }
-  wss.on("connection", (ws) => {
+  wss2.on("connection", (ws) => {
     if (closeTimer) {
       clearTimeout(closeTimer);
       closeTimer = null;
@@ -1182,10 +1252,10 @@ function createWatchBridge(port, callbacks) {
           if (closeTimer) {
             clearTimeout(closeTimer);
           }
-          for (const ws of wss.clients) {
+          for (const ws of wss2.clients) {
             ws.close();
           }
-          wss.close();
+          wss2.close();
           await new Promise((resolve2) => {
             httpServer.close(() => resolve2());
           });
@@ -1369,10 +1439,371 @@ Review submitted: ${result.decision}`);
   return { stop, updateContext };
 }
 
+// packages/core/src/global-server.ts
+import http3 from "http";
+import { randomUUID } from "crypto";
+import getPort3 from "get-port";
+import open3 from "open";
+import { WebSocketServer as WebSocketServer3, WebSocket as WebSocket3 } from "ws";
+var sessions2 = /* @__PURE__ */ new Map();
+var clientSessions = /* @__PURE__ */ new Map();
+function toSummary(session) {
+  const { payload } = session;
+  const fileCount = payload.diffSet.files.length;
+  let additions = 0;
+  let deletions = 0;
+  for (const file of payload.diffSet.files) {
+    additions += file.additions;
+    deletions += file.deletions;
+  }
+  return {
+    id: session.id,
+    projectPath: session.projectPath,
+    branch: payload.metadata.currentBranch,
+    title: payload.metadata.title,
+    fileCount,
+    additions,
+    deletions,
+    status: session.status,
+    createdAt: session.createdAt
+  };
+}
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    let body = "";
+    req.on("data", (chunk) => {
+      body += chunk.toString();
+    });
+    req.on("end", () => resolve(body));
+    req.on("error", reject);
+  });
+}
+function jsonResponse(res, status, data) {
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(data));
+}
+function matchRoute(method, url, expectedMethod, pattern) {
+  if (method !== expectedMethod) return null;
+  const patternParts = pattern.split("/");
+  const urlParts = url.split("/");
+  if (patternParts.length !== urlParts.length) return null;
+  const params = {};
+  for (let i = 0; i < patternParts.length; i++) {
+    if (patternParts[i].startsWith(":")) {
+      params[patternParts[i].slice(1)] = urlParts[i];
+    } else if (patternParts[i] !== urlParts[i]) {
+      return null;
+    }
+  }
+  return params;
+}
+var wss = null;
+function broadcastToAll(msg) {
+  if (!wss) return;
+  const data = JSON.stringify(msg);
+  for (const client of wss.clients) {
+    if (client.readyState === WebSocket3.OPEN) {
+      client.send(data);
+    }
+  }
+}
+function sendToSessionClients(sessionId, msg) {
+  if (!wss) return;
+  const data = JSON.stringify(msg);
+  for (const [client, sid] of clientSessions.entries()) {
+    if (sid === sessionId && client.readyState === WebSocket3.OPEN) {
+      client.send(data);
+    }
+  }
+}
+async function handleApiRequest(req, res) {
+  const method = req.method ?? "GET";
+  const url = (req.url ?? "/").split("?")[0];
+  res.setHeader("Access-Control-Allow-Origin", "*");
+  res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+  res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+  if (method === "OPTIONS") {
+    res.writeHead(204);
+    res.end();
+    return true;
+  }
+  if (!url.startsWith("/api/")) {
+    return false;
+  }
+  if (method === "GET" && url === "/api/status") {
+    jsonResponse(res, 200, {
+      running: true,
+      pid: process.pid,
+      sessions: sessions2.size,
+      uptime: process.uptime()
+    });
+    return true;
+  }
+  if (method === "POST" && url === "/api/reviews") {
+    try {
+      const body = await readBody(req);
+      const { payload, projectPath } = JSON.parse(body);
+      const sessionId = `session-${randomUUID().slice(0, 8)}`;
+      payload.reviewId = sessionId;
+      const session = {
+        id: sessionId,
+        payload,
+        projectPath,
+        status: "pending",
+        createdAt: Date.now(),
+        result: null
+      };
+      sessions2.set(sessionId, session);
+      broadcastToAll({
+        type: "session:added",
+        payload: toSummary(session)
+      });
+      jsonResponse(res, 201, { sessionId });
+    } catch {
+      jsonResponse(res, 400, { error: "Invalid request body" });
+    }
+    return true;
+  }
+  if (method === "GET" && url === "/api/reviews") {
+    const summaries = Array.from(sessions2.values()).map(toSummary);
+    jsonResponse(res, 200, { sessions: summaries });
+    return true;
+  }
+  const getReviewParams = matchRoute(method, url, "GET", "/api/reviews/:id");
+  if (getReviewParams) {
+    const session = sessions2.get(getReviewParams.id);
+    if (!session) {
+      jsonResponse(res, 404, { error: "Session not found" });
+      return true;
+    }
+    jsonResponse(res, 200, toSummary(session));
+    return true;
+  }
+  const postResultParams = matchRoute(method, url, "POST", "/api/reviews/:id/result");
+  if (postResultParams) {
+    const session = sessions2.get(postResultParams.id);
+    if (!session) {
+      jsonResponse(res, 404, { error: "Session not found" });
+      return true;
+    }
+    try {
+      const body = await readBody(req);
+      const result = JSON.parse(body);
+      session.result = result;
+      session.status = "submitted";
+      jsonResponse(res, 200, { ok: true });
+    } catch {
+      jsonResponse(res, 400, { error: "Invalid request body" });
+    }
+    return true;
+  }
+  const getResultParams = matchRoute(method, url, "GET", "/api/reviews/:id/result");
+  if (getResultParams) {
+    const session = sessions2.get(getResultParams.id);
+    if (!session) {
+      jsonResponse(res, 404, { error: "Session not found" });
+      return true;
+    }
+    if (session.result) {
+      jsonResponse(res, 200, { result: session.result, status: "submitted" });
+    } else {
+      jsonResponse(res, 200, { result: null, status: session.status });
+    }
+    return true;
+  }
+  const postContextParams = matchRoute(method, url, "POST", "/api/reviews/:id/context");
+  if (postContextParams) {
+    const session = sessions2.get(postContextParams.id);
+    if (!session) {
+      jsonResponse(res, 404, { error: "Session not found" });
+      return true;
+    }
+    try {
+      const body = await readBody(req);
+      const contextPayload = JSON.parse(body);
+      if (contextPayload.reasoning !== void 0) {
+        session.payload.metadata.reasoning = contextPayload.reasoning;
+      }
+      if (contextPayload.title !== void 0) {
+        session.payload.metadata.title = contextPayload.title;
+      }
+      if (contextPayload.description !== void 0) {
+        session.payload.metadata.description = contextPayload.description;
+      }
+      sendToSessionClients(session.id, {
+        type: "context:update",
+        payload: contextPayload
+      });
+      jsonResponse(res, 200, { ok: true });
+    } catch {
+      jsonResponse(res, 400, { error: "Invalid request body" });
+    }
+    return true;
+  }
+  const deleteParams = matchRoute(method, url, "DELETE", "/api/reviews/:id");
+  if (deleteParams) {
+    if (sessions2.delete(deleteParams.id)) {
+      jsonResponse(res, 200, { ok: true });
+    } else {
+      jsonResponse(res, 404, { error: "Session not found" });
+    }
+    return true;
+  }
+  jsonResponse(res, 404, { error: "Not found" });
+  return true;
+}
+async function startGlobalServer(options = {}) {
+  const {
+    httpPort: preferredHttpPort = 24680,
+    wsPort: preferredWsPort = 24681,
+    silent = false,
+    dev = false
+  } = options;
+  const [httpPort, wsPort] = await Promise.all([
+    getPort3({ port: preferredHttpPort }),
+    getPort3({ port: preferredWsPort })
+  ]);
+  let uiPort;
+  let uiHttpServer = null;
+  let viteServer = null;
+  if (dev) {
+    uiPort = await getPort3();
+    const uiRoot = resolveUiRoot();
+    viteServer = await startViteDevServer(uiRoot, uiPort, silent);
+  } else {
+    uiPort = await getPort3();
+    const uiDist = resolveUiDist();
+    uiHttpServer = await createStaticServer(uiDist, uiPort);
+  }
+  const httpServer = http3.createServer(async (req, res) => {
+    const handled = await handleApiRequest(req, res);
+    if (!handled) {
+      res.writeHead(404);
+      res.end("Not found");
+    }
+  });
+  wss = new WebSocketServer3({ port: wsPort });
+  wss.on("connection", (ws, req) => {
+    const url = new URL(req.url ?? "/", `http://localhost:${wsPort}`);
+    const sessionId = url.searchParams.get("sessionId");
+    if (sessionId) {
+      clientSessions.set(ws, sessionId);
+      const session = sessions2.get(sessionId);
+      if (session) {
+        session.status = "in_review";
+        const msg = {
+          type: "review:init",
+          payload: session.payload
+        };
+        ws.send(JSON.stringify(msg));
+      }
+    } else {
+      const summaries = Array.from(sessions2.values()).map(toSummary);
+      const msg = {
+        type: "session:list",
+        payload: summaries
+      };
+      ws.send(JSON.stringify(msg));
+      if (summaries.length === 1) {
+        const session = sessions2.get(summaries[0].id);
+        if (session) {
+          clientSessions.set(ws, session.id);
+          session.status = "in_review";
+          ws.send(JSON.stringify({
+            type: "review:init",
+            payload: session.payload
+          }));
+        }
+      }
+    }
+    ws.on("message", (data) => {
+      try {
+        const msg = JSON.parse(data.toString());
+        if (msg.type === "review:submit") {
+          const sid = clientSessions.get(ws);
+          if (sid) {
+            const session = sessions2.get(sid);
+            if (session) {
+              session.result = msg.payload;
+              session.status = "submitted";
+            }
+          }
+        } else if (msg.type === "session:select") {
+          const session = sessions2.get(msg.payload.sessionId);
+          if (session) {
+            clientSessions.set(ws, session.id);
+            session.status = "in_review";
+            ws.send(JSON.stringify({
+              type: "review:init",
+              payload: session.payload
+            }));
+          }
+        }
+      } catch {
+      }
+    });
+    ws.on("close", () => {
+      clientSessions.delete(ws);
+    });
+  });
+  await new Promise((resolve, reject) => {
+    httpServer.on("error", reject);
+    httpServer.listen(httpPort, () => resolve());
+  });
+  const serverInfo = {
+    httpPort,
+    wsPort,
+    pid: process.pid,
+    startedAt: Date.now()
+  };
+  writeServerFile(serverInfo);
+  if (!silent) {
+    console.log(`
+DiffPrism Global Server`);
+    console.log(`  API:  http://localhost:${httpPort}`);
+    console.log(`  WS:   ws://localhost:${wsPort}`);
+    console.log(`  UI:   http://localhost:${uiPort}`);
+    console.log(`  PID:  ${process.pid}`);
+    console.log(`
+Waiting for reviews...
+`);
+  }
+  const uiUrl = `http://localhost:${uiPort}?wsPort=${wsPort}&serverMode=true`;
+  await open3(uiUrl);
+  async function stop() {
+    if (wss) {
+      for (const client of wss.clients) {
+        client.close();
+      }
+      wss.close();
+      wss = null;
+    }
+    clientSessions.clear();
+    sessions2.clear();
+    await new Promise((resolve) => {
+      httpServer.close(() => resolve());
+    });
+    if (viteServer) {
+      await viteServer.close();
+    }
+    if (uiHttpServer) {
+      uiHttpServer.close();
+    }
+    removeServerFile();
+  }
+  return { httpPort, wsPort, stop };
+}
+
 export {
+  getCurrentBranch,
+  getDiff,
+  analyze,
   startReview,
   readWatchFile,
   readReviewResult,
   consumeReviewResult,
-  startWatch
+  startWatch,
+  readServerFile,
+  isServerAlive,
+  startGlobalServer
 };