@dmsdc-ai/aigentry-deliberation 0.0.1

package/install.js

@@ -0,0 +1,202 @@
+#!/usr/bin/env node
+
+/**
+ * Deliberation MCP Server — One-click installer
+ *
+ * Usage:
+ *   npx @dmsdc-ai/aigentry-deliberation install
+ *   node install.js
+ *
+ * What it does:
+ *   1. Copies server files to ~/.local/lib/mcp-deliberation/
+ *   2. Installs npm dependencies
+ *   3. Registers MCP server in ~/.claude/.mcp.json
+ *   4. Ready to use — next Claude Code session will auto-load
+ */
+
+import { execSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const HOME = process.env.HOME || process.env.USERPROFILE || "";
+const IS_WIN = process.platform === "win32";
+const INSTALL_DIR = IS_WIN
+  ? path.join(process.env.LOCALAPPDATA || path.join(HOME, "AppData", "Local"), "mcp-deliberation")
+  : path.join(HOME, ".local", "lib", "mcp-deliberation");
+const MCP_CONFIG = path.join(HOME, ".claude", ".mcp.json");
+
+/** Normalize path to forward slashes for JSON config (Windows backslash → forward slash) */
+function toForwardSlash(p) {
+  return p.replace(/\\/g, "/");
+}
+
+const FILES_TO_COPY = [
+  "index.js",
+  "observer.js",
+  "browser-control-port.js",
+  "degradation-state-machine.js",
+  "session-monitor.sh",
+  "session-monitor-win.js",
+  "package.json",
+  "package-lock.json",
+];
+
+const DIRS_TO_COPY = ["selectors", "public", "skills"];
+
+function log(msg) {
+  console.log(`  ${msg}`);
+}
+
+function copyFileIfExists(src, dest) {
+  if (fs.existsSync(src)) {
+    fs.copyFileSync(src, dest);
+    return true;
+  }
+  return false;
+}
+
+function copyDirRecursive(src, dest) {
+  if (!fs.existsSync(src)) return;
+  fs.mkdirSync(dest, { recursive: true });
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDirRecursive(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+function install() {
+  console.log("\n🎯 Deliberation MCP Server — 설치 시작\n");
+
+  // Step 1: Create install directory
+  log("📁 설치 디렉토리 생성...");
+  fs.mkdirSync(INSTALL_DIR, { recursive: true });
+  log(`   → ${INSTALL_DIR}`);
+
+  // Step 2: Copy files
+  log("📦 서버 파일 복사...");
+  let copied = 0;
+  for (const file of FILES_TO_COPY) {
+    if (copyFileIfExists(path.join(__dirname, file), path.join(INSTALL_DIR, file))) {
+      copied++;
+    }
+  }
+  for (const dir of DIRS_TO_COPY) {
+    const src = path.join(__dirname, dir);
+    if (fs.existsSync(src)) {
+      copyDirRecursive(src, path.join(INSTALL_DIR, dir));
+      copied++;
+    }
+  }
+  log(`   → ${copied}개 항목 복사 완료`);
+
+  // Step 3: Install dependencies
+  log("📥 의존성 설치...");
+  try {
+    execSync("npm install --production --no-audit --no-fund", {
+      cwd: INSTALL_DIR,
+      stdio: "pipe",
+    });
+    log("   → npm install 완료");
+  } catch (err) {
+    log(`   ⚠️ npm install 실패: ${err.message}`);
+    log("   수동 실행: cd ~/.local/lib/mcp-deliberation && npm install");
+  }
+
+  // Step 4: Register MCP server
+  log("🔧 Claude Code MCP 서버 등록...");
+  const claudeDir = path.join(HOME, ".claude");
+  fs.mkdirSync(claudeDir, { recursive: true });
+
+  let mcpConfig = {};
+  if (fs.existsSync(MCP_CONFIG)) {
+    try {
+      mcpConfig = JSON.parse(fs.readFileSync(MCP_CONFIG, "utf-8"));
+    } catch {
+      mcpConfig = {};
+    }
+  }
+
+  if (!mcpConfig.mcpServers) mcpConfig.mcpServers = {};
+
+  const alreadyRegistered = !!mcpConfig.mcpServers.deliberation;
+  mcpConfig.mcpServers.deliberation = {
+    command: "node",
+    args: [toForwardSlash(path.join(INSTALL_DIR, "index.js"))],
+  };
+
+  fs.writeFileSync(MCP_CONFIG, JSON.stringify(mcpConfig, null, 2));
+  log(alreadyRegistered
+    ? "   → 기존 등록 업데이트 완료"
+    : "   → 새로 등록 완료");
+
+  // Step 5: Make session-monitor.sh executable
+  const monitorScript = path.join(INSTALL_DIR, "session-monitor.sh");
+  if (fs.existsSync(monitorScript)) {
+    try {
+      fs.chmodSync(monitorScript, 0o755);
+    } catch { /* ignore on Windows */ }
+  }
+
+  // Step 6: Preserve existing config
+  const configPath = path.join(INSTALL_DIR, "config.json");
+  if (!fs.existsSync(configPath)) {
+    fs.writeFileSync(configPath, JSON.stringify({}, null, 2));
+  }
+
+  // Done
+  console.log("\n✅ 설치 완료!\n");
+  console.log("  다음 단계:");
+  console.log("  1. Claude Code 세션을 재시작하세요");
+  console.log("  2. \"토론 시작해\" 또는 deliberation_start(topic: \"...\") 호출");
+  console.log("  3. 첫 사용 시 온보딩 위저드가 기본 설정을 안내합니다\n");
+}
+
+// Entry point
+const args = process.argv.slice(2);
+if (args.includes("--help") || args.includes("-h")) {
+  console.log(`
+Deliberation MCP Server Installer
+
+Usage:
+  npx @dmsdc-ai/aigentry-deliberation install
+  node install.js
+
+Options:
+  --help, -h     이 도움말 표시
+  --uninstall    서버 제거
+
+설치 경로: ${INSTALL_DIR}
+MCP 설정:  ${MCP_CONFIG}
+`);
+} else if (args.includes("--uninstall") || args.includes("uninstall")) {
+  console.log("\n🗑️ Deliberation MCP Server 제거\n");
+
+  // Remove from MCP config
+  if (fs.existsSync(MCP_CONFIG)) {
+    try {
+      const mcpConfig = JSON.parse(fs.readFileSync(MCP_CONFIG, "utf-8"));
+      if (mcpConfig.mcpServers?.deliberation) {
+        delete mcpConfig.mcpServers.deliberation;
+        fs.writeFileSync(MCP_CONFIG, JSON.stringify(mcpConfig, null, 2));
+        log("MCP 등록 해제 완료");
+      }
+    } catch { /* ignore */ }
+  }
+
+  // Remove install directory
+  if (fs.existsSync(INSTALL_DIR)) {
+    fs.rmSync(INSTALL_DIR, { recursive: true, force: true });
+    log("설치 디렉토리 삭제 완료");
+  }
+
+  console.log("\n✅ 제거 완료. Claude Code를 재시작하세요.\n");
+} else {
+  install();
+}

package/observer.js

@@ -0,0 +1,483 @@
+#!/usr/bin/env node
+/**
+ * Deliberation Observer — SSE + Minimal Dashboard
+ *
+ * Usage:
+ *   node observer.js [--port 3847]
+ *   npx aigentry-deliberation --dashboard
+ *
+ * Provides:
+ *   GET /                          → HTML dashboard
+ *   GET /api/sessions              → JSON list of active sessions
+ *   GET /api/sessions/:id          → JSON session detail
+ *   GET /api/sessions/:id/stream   → SSE real-time log stream
+ */
+
+import http from "http";
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { fileURLToPath } from "url";
+import { execSync } from "child_process";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const STATE_DIR = path.join(os.homedir(), ".local", "lib", "mcp-deliberation", "state");
+const CONFIG_PATH = path.join(os.homedir(), ".local", "lib", "mcp-deliberation", "config.json");
+const DEFAULT_CLI_CANDIDATES = ["claude", "codex", "gemini", "qwen", "chatgpt", "aider", "llm", "opencode", "cursor", "continue"];
+const CLI_LABELS = {
+  claude: "Claude", codex: "Codex", gemini: "Gemini", qwen: "Qwen",
+  chatgpt: "ChatGPT", aider: "Aider", llm: "LLM (Simon)",
+  opencode: "OpenCode", cursor: "Cursor", continue: "Continue"
+};
+const DEFAULT_PORT = 3847;
+
+function getProjectSlug() {
+  const cwd = process.cwd();
+  return path.basename(cwd).toLowerCase().replace(/[^a-z0-9_-]/g, "-");
+}
+
+function listSessions(projectSlug) {
+  const sessionsDir = path.join(STATE_DIR, projectSlug || "", "sessions");
+  try {
+    const files = fs.readdirSync(sessionsDir).filter(f => f.endsWith(".json"));
+    return files.map(f => {
+      try {
+        return JSON.parse(fs.readFileSync(path.join(sessionsDir, f), "utf-8"));
+      } catch { return null; }
+    }).filter(Boolean);
+  } catch { return []; }
+}
+
+function findSession(sessionId) {
+  // Search all project slugs
+  try {
+    const slugs = fs.readdirSync(STATE_DIR).filter(f => {
+      const stat = fs.statSync(path.join(STATE_DIR, f));
+      return stat.isDirectory();
+    });
+    for (const slug of slugs) {
+      const sessionsDir = path.join(STATE_DIR, slug, "sessions");
+      const filePath = path.join(sessionsDir, `${sessionId}.json`);
+      try {
+        return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+      } catch { continue; }
+    }
+  } catch {}
+  return null;
+}
+
+function getAllActiveSessions() {
+  const all = [];
+  try {
+    const slugs = fs.readdirSync(STATE_DIR).filter(f => {
+      try { return fs.statSync(path.join(STATE_DIR, f)).isDirectory(); } catch { return false; }
+    });
+    for (const slug of slugs) {
+      const sessions = listSessions(slug);
+      all.push(...sessions.filter(s => s.status === "active"));
+    }
+  } catch {}
+  return all;
+}
+
+// SSE connections per session
+const sseClients = new Map();
+
+function broadcastSessionUpdate(sessionId, event, data) {
+  const clients = sseClients.get(sessionId) || [];
+  const payload = `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
+  clients.forEach(res => {
+    try { res.write(payload); } catch {}
+  });
+}
+
+// Poll for session changes
+const sessionSnapshots = new Map();
+function pollSessions() {
+  for (const [sessionId, clients] of sseClients.entries()) {
+    if (clients.length === 0) continue;
+    const session = findSession(sessionId);
+    if (!session) continue;
+    const prev = sessionSnapshots.get(sessionId);
+    const currentLogLen = session.log?.length || 0;
+    const prevLogLen = prev?.logLength || 0;
+
+    if (currentLogLen > prevLogLen) {
+      // New log entries
+      const newEntries = session.log.slice(prevLogLen);
+      for (const entry of newEntries) {
+        broadcastSessionUpdate(sessionId, "turn", entry);
+      }
+    }
+
+    if (prev?.status !== session.status) {
+      broadcastSessionUpdate(sessionId, "status", {
+        status: session.status,
+        current_speaker: session.current_speaker,
+        current_round: session.current_round,
+      });
+    }
+
+    sessionSnapshots.set(sessionId, {
+      logLength: currentLogLen,
+      status: session.status,
+    });
+  }
+}
+
+// HTML dashboard
+function getDashboardHtml() {
+  const htmlPath = path.join(__dirname, "public", "index.html");
+  try {
+    return fs.readFileSync(htmlPath, "utf-8");
+  } catch {
+    return `<!DOCTYPE html><html><body><h1>Dashboard file not found</h1><p>Expected: ${htmlPath}</p></body></html>`;
+  }
+}
+
+function loadConfig() {
+  try {
+    return JSON.parse(fs.readFileSync(CONFIG_PATH, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+
+function saveConfig(config) {
+  const dir = path.dirname(CONFIG_PATH);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), "utf-8");
+}
+
+function checkCliInstalled(name) {
+  try {
+    execSync(`which ${name}`, { stdio: 'ignore' });
+    return true;
+  } catch { return false; }
+}
+
+function fetchCdpTargets() {
+  return new Promise((resolve) => {
+    const req = http.get("http://localhost:9222/json", (res) => {
+      let data = "";
+      res.on("data", chunk => data += chunk);
+      res.on("end", () => {
+        try {
+          const targets = JSON.parse(data);
+          const llmPatterns = /claude|chatgpt|openai|gemini|bard|copilot|perplexity|deepseek|qwen/i;
+          const llmTabs = targets
+            .filter(t => t.type === "page" && (llmPatterns.test(t.url) || llmPatterns.test(t.title)))
+            .map(t => ({ title: t.title, url: t.url, id: t.id }));
+          resolve({ cdp_available: true, tabs: llmTabs });
+        } catch { resolve({ cdp_available: true, tabs: [] }); }
+      });
+    });
+    req.on("error", () => resolve({ cdp_available: false, tabs: [], message: "CDP not available. Launch Chrome with --remote-debugging-port=9222" }));
+    req.setTimeout(2000, () => { req.destroy(); resolve({ cdp_available: false, tabs: [], message: "CDP connection timeout" }); });
+  });
+}
+
+function createSession(topic, speakers, maxRounds) {
+  const id = `obs-${Date.now().toString(36)}`;
+  const projectSlug = getProjectSlug();
+  const sessionsDir = path.join(STATE_DIR, projectSlug, "sessions");
+
+  fs.mkdirSync(sessionsDir, { recursive: true });
+
+  const session = {
+    id,
+    topic: topic || "Untitled Discussion",
+    speakers: speakers || ["claude", "gemini"],
+    status: "active",
+    current_round: 1,
+    max_rounds: maxRounds || 3,
+    current_speaker: speakers?.[0] || "claude",
+    ordering_strategy: "cyclic",
+    log: [],
+    created_at: new Date().toISOString(),
+    created_by: "observer",
+  };
+
+  fs.writeFileSync(path.join(sessionsDir, `${id}.json`), JSON.stringify(session, null, 2));
+  return session;
+}
+
+function computeStats() {
+  const stats = {
+    total_sessions: 0,
+    total_turns: 0,
+    speakers: {},
+  };
+
+  try {
+    const slugs = fs.readdirSync(STATE_DIR).filter(f => {
+      try { return fs.statSync(path.join(STATE_DIR, f)).isDirectory(); } catch { return false; }
+    });
+
+    for (const slug of slugs) {
+      const sessionsDir = path.join(STATE_DIR, slug, "sessions");
+      let files;
+      try { files = fs.readdirSync(sessionsDir).filter(f => f.endsWith(".json")); } catch { continue; }
+
+      for (const file of files) {
+        try {
+          const session = JSON.parse(fs.readFileSync(path.join(sessionsDir, file), "utf-8"));
+          stats.total_sessions++;
+
+          for (const entry of (session.log || [])) {
+            stats.total_turns++;
+            const sp = entry.speaker;
+            if (!sp) continue;
+
+            if (!stats.speakers[sp]) {
+              stats.speakers[sp] = { turns: 0, votes: { agree: 0, disagree: 0, conditional: 0 }, total_length: 0 };
+            }
+            stats.speakers[sp].turns++;
+            stats.speakers[sp].total_length += (entry.content || "").length;
+
+            for (const v of (entry.votes || [])) {
+              const key = v.toLowerCase();
+              if (key in stats.speakers[sp].votes) stats.speakers[sp].votes[key]++;
+            }
+          }
+        } catch { continue; }
+      }
+    }
+
+    for (const sp of Object.keys(stats.speakers)) {
+      const s = stats.speakers[sp];
+      s.avg_length = s.turns > 0 ? Math.round(s.total_length / s.turns) : 0;
+      delete s.total_length;
+    }
+  } catch {}
+
+  return stats;
+}
+
+// HTTP Server
+function createServer(port) {
+  const server = http.createServer((req, res) => {
+    const url = new URL(req.url, `http://localhost:${port}`);
+    const pathname = url.pathname;
+
+    // CORS
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+
+    // OPTIONS preflight
+    if (req.method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+
+    // Routes
+    if (pathname === "/" || pathname === "/index.html") {
+      res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+      res.end(getDashboardHtml());
+      return;
+    }
+
+    if (pathname === "/api/sessions") {
+      const sessions = getAllActiveSessions();
+      const summary = sessions.map(s => ({
+        id: s.id,
+        topic: s.topic,
+        status: s.status,
+        current_round: s.current_round,
+        max_rounds: s.max_rounds,
+        current_speaker: s.current_speaker,
+        speakers: s.speakers,
+        log_count: s.log?.length || 0,
+        created: s.created,
+      }));
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify(summary));
+      return;
+    }
+
+    if (pathname === "/api/sessions/start" && req.method === "POST") {
+      let body = "";
+      req.on("data", chunk => { body += chunk; });
+      req.on("end", () => {
+        let parsed;
+        try {
+          parsed = JSON.parse(body);
+        } catch {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Invalid JSON" }));
+          return;
+        }
+        if (!parsed.topic) {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "topic is required" }));
+          return;
+        }
+        try {
+          const session = createSession(parsed.topic, parsed.speakers, parsed.max_rounds);
+          res.writeHead(201, { "Content-Type": "application/json" });
+          res.end(JSON.stringify(session));
+        } catch (err) {
+          res.writeHead(500, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: String(err) }));
+        }
+      });
+      return;
+    }
+
+    const sessionMatch = pathname.match(/^\/api\/sessions\/([^/]+)$/);
+    if (sessionMatch) {
+      const session = findSession(sessionMatch[1]);
+      if (!session) {
+        res.writeHead(404, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Session not found" }));
+        return;
+      }
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify(session));
+      return;
+    }
+
+    const streamMatch = pathname.match(/^\/api\/sessions\/([^/]+)\/stream$/);
+    if (streamMatch) {
+      const sessionId = streamMatch[1];
+      const session = findSession(sessionId);
+      if (!session) {
+        res.writeHead(404, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Session not found" }));
+        return;
+      }
+
+      // SSE setup
+      res.writeHead(200, {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        "Connection": "keep-alive",
+      });
+      res.write(`event: connected\ndata: ${JSON.stringify({ session_id: sessionId })}\n\n`);
+
+      // Send current state
+      res.write(`event: snapshot\ndata: ${JSON.stringify({
+        status: session.status,
+        current_speaker: session.current_speaker,
+        current_round: session.current_round,
+        max_rounds: session.max_rounds,
+        speakers: session.speakers,
+        log: session.log,
+      })}\n\n`);
+
+      // Register client
+      if (!sseClients.has(sessionId)) sseClients.set(sessionId, []);
+      sseClients.get(sessionId).push(res);
+      sessionSnapshots.set(sessionId, {
+        logLength: session.log?.length || 0,
+        status: session.status,
+      });
+
+      req.on("close", () => {
+        const clients = sseClients.get(sessionId) || [];
+        sseClients.set(sessionId, clients.filter(c => c !== res));
+      });
+      return;
+    }
+
+    if (pathname === "/api/config" && req.method === "GET") {
+      const config = loadConfig();
+      const enabledClis = Array.isArray(config.enabled_clis) ? config.enabled_clis : [];
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({
+        mode: enabledClis.length === 0 ? "auto-detect" : "config",
+        enabled_clis: enabledClis,
+        all_clis: DEFAULT_CLI_CANDIDATES,
+        updated: config.updated || null,
+      }));
+      return;
+    }
+
+    if (pathname === "/api/config" && req.method === "POST") {
+      let body = "";
+      req.on("data", chunk => { body += chunk; });
+      req.on("end", () => {
+        let parsed;
+        try {
+          parsed = JSON.parse(body);
+        } catch {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Invalid JSON" }));
+          return;
+        }
+        const enabledClis = Array.isArray(parsed.enabled_clis) ? parsed.enabled_clis : [];
+        const config = {
+          enabled_clis: enabledClis,
+          updated: new Date().toISOString(),
+        };
+        saveConfig(config);
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({
+          mode: enabledClis.length === 0 ? "auto-detect" : "config",
+          enabled_clis: enabledClis,
+          all_clis: DEFAULT_CLI_CANDIDATES,
+          updated: config.updated,
+        }));
+      });
+      return;
+    }
+
+    if (pathname === "/api/cli-status" && req.method === "GET") {
+      const clis = DEFAULT_CLI_CANDIDATES.map(name => ({
+        name,
+        label: CLI_LABELS[name] || name,
+        installed: checkCliInstalled(name),
+      }));
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ clis }));
+      return;
+    }
+
+    if (pathname === "/api/browser-tabs" && req.method === "GET") {
+      (async () => {
+        const tabs = await fetchCdpTargets();
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify(tabs));
+      })().catch(err => {
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: String(err) }));
+      });
+      return;
+    }
+
+    if (pathname === "/api/stats" && req.method === "GET") {
+      const stats = computeStats();
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify(stats));
+      return;
+    }
+
+    res.writeHead(404, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "Not found" }));
+  });
+
+  return server;
+}
+
+// Main
+const port = parseInt(process.argv.find((_, i, a) => a[i - 1] === "--port") || DEFAULT_PORT);
+const server = createServer(port);
+
+// Poll every 1 second
+const pollInterval = setInterval(pollSessions, 1000);
+
+server.listen(port, () => {
+  console.log(`Deliberation Observer running at http://localhost:${port}`);
+  console.log(`   Dashboard: http://localhost:${port}/`);
+  console.log(`   API: http://localhost:${port}/api/sessions`);
+  console.log(`   SSE: http://localhost:${port}/api/sessions/{id}/stream`);
+  console.log(`\n   Press Ctrl+C to stop.`);
+});
+
+process.on("SIGINT", () => {
+  clearInterval(pollInterval);
+  server.close();
+  process.exit(0);
+});