md4ai 0.5.2 → 0.6.1

package/dist/index.bundled.js

@@ -1001,9 +1001,9 @@ function identifyRoots(allFiles, projectRoot) {
   return roots;
 }
 async function readClaudeConfigFiles(projectRoot) {
-  const { readFile: readFile7, stat, glob } = await import("node:fs/promises");
-  const { join: join11, relative: relative2 } = await import("node:path");
-  const { existsSync: existsSync10 } = await import("node:fs");
+  const { readFile: readFile8, stat, glob } = await import("node:fs/promises");
+  const { join: join12, relative: relative2 } = await import("node:path");
+  const { existsSync: existsSync11 } = await import("node:fs");
   const configPatterns = [
     "CLAUDE.md",
     ".claude/CLAUDE.md",
@@ -1013,11 +1013,11 @@ async function readClaudeConfigFiles(projectRoot) {
   ];
   const files = [];
   for (const pattern of configPatterns) {
-    for await (const fullPath of glob(join11(projectRoot, pattern))) {
-      if (!existsSync10(fullPath))
+    for await (const fullPath of glob(join12(projectRoot, pattern))) {
+      if (!existsSync11(fullPath))
         continue;
       try {
-        const content = await readFile7(fullPath, "utf-8");
+        const content = await readFile8(fullPath, "utf-8");
         const fileStat = await stat(fullPath);
         const lastMod = getGitLastModified(fullPath, projectRoot);
         files.push({
@@ -1161,7 +1161,7 @@ function escapeHtml(text) {
 
 // dist/check-update.js
 import chalk8 from "chalk";
-var CURRENT_VERSION = "0.5.2";
+var CURRENT_VERSION = "0.6.1";
 async function checkForUpdate() {
   try {
     const controller = new AbortController();
@@ -1524,8 +1524,10 @@ async function syncCommand(options) {
 
 // dist/commands/link.js
 import { resolve as resolve4 } from "node:path";
-import { hostname as hostname2, platform as platform2 } from "node:os";
 import chalk13 from "chalk";
+
+// dist/device-utils.js
+import { hostname as hostname2, platform as platform2 } from "node:os";
 function detectOs2() {
   const p = platform2();
   if (p === "win32")
@@ -1542,6 +1544,22 @@ function detectDeviceName() {
   const osLabel = os.charAt(0).toUpperCase() + os.slice(1);
   return `${host}-${osLabel}`;
 }
+async function resolveDeviceId(supabase, userId) {
+  const deviceName = detectDeviceName();
+  const osType = detectOs2();
+  await supabase.from("devices").upsert({
+    user_id: userId,
+    device_name: deviceName,
+    os_type: osType
+  }, { onConflict: "user_id,device_name" });
+  const { data, error } = await supabase.from("devices").select("id").eq("user_id", userId).eq("device_name", deviceName).single();
+  if (error || !data) {
+    throw new Error(`Failed to resolve device ID: ${error?.message ?? "not found"}`);
+  }
+  return data.id;
+}
+
+// dist/commands/link.js
 async function linkCommand(projectId) {
   const { supabase, userId } = await getAuthenticatedClient();
   const cwd = resolve4(process.cwd());
@@ -1982,6 +2000,394 @@ async function fetchGitHubVersions(repo, signal) {
   return { stable, beta };
 }
 
+// dist/commands/mcp-watch.js
+import chalk18 from "chalk";
+
+// dist/mcp/read-configs.js
+import { readFile as readFile7 } from "node:fs/promises";
+import { join as join11 } from "node:path";
+import { homedir as homedir7 } from "node:os";
+import { existsSync as existsSync10 } from "node:fs";
+import { readdir as readdir3 } from "node:fs/promises";
+async function readJsonSafe(path) {
+  try {
+    if (!existsSync10(path))
+      return null;
+    const raw = await readFile7(path, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function extractPackageName(args) {
+  for (const arg of args) {
+    if (arg.startsWith("-"))
+      continue;
+    if (arg.includes("mcp") || arg.startsWith("@"))
+      return arg;
+  }
+  for (const arg of args) {
+    if (!arg.startsWith("-"))
+      return arg;
+  }
+  return null;
+}
+function parseServers(data, source) {
+  if (!data?.mcpServers)
+    return [];
+  const entries = [];
+  for (const [name, server] of Object.entries(data.mcpServers)) {
+    const serverType = server.type === "http" ? "http" : "stdio";
+    entries.push({
+      name,
+      source,
+      type: serverType,
+      command: server.command,
+      args: server.args,
+      env: server.env,
+      url: server.url
+    });
+  }
+  return entries;
+}
+function parseFlatConfig(data, source) {
+  if (!data)
+    return [];
+  const entries = [];
+  for (const [name, server] of Object.entries(data)) {
+    if (typeof server !== "object" || server === null)
+      continue;
+    if (!server.command && !server.url)
+      continue;
+    const serverType = server.type === "http" ? "http" : "stdio";
+    entries.push({
+      name,
+      source,
+      type: serverType,
+      command: server.command,
+      args: server.args,
+      env: server.env,
+      url: server.url
+    });
+  }
+  return entries;
+}
+async function readAllMcpConfigs() {
+  const home = homedir7();
+  const entries = [];
+  const userConfig = await readJsonSafe(join11(home, ".claude.json"));
+  entries.push(...parseServers(userConfig, "global"));
+  const globalMcp = await readJsonSafe(join11(home, ".claude", "mcp.json"));
+  entries.push(...parseServers(globalMcp, "global"));
+  const cwdMcp = await readJsonSafe(join11(process.cwd(), ".mcp.json"));
+  entries.push(...parseServers(cwdMcp, "project"));
+  const pluginsBase = join11(home, ".claude", "plugins", "marketplaces");
+  if (existsSync10(pluginsBase)) {
+    try {
+      const marketplaces = await readdir3(pluginsBase, { withFileTypes: true });
+      for (const mp of marketplaces) {
+        if (!mp.isDirectory())
+          continue;
+        const extDir = join11(pluginsBase, mp.name, "external_plugins");
+        if (!existsSync10(extDir))
+          continue;
+        const plugins = await readdir3(extDir, { withFileTypes: true });
+        for (const plugin of plugins) {
+          if (!plugin.isDirectory())
+            continue;
+          const pluginMcp = await readJsonSafe(join11(extDir, plugin.name, ".mcp.json"));
+          entries.push(...parseServers(pluginMcp, "plugin"));
+        }
+      }
+    } catch {
+    }
+  }
+  const cacheBase = join11(home, ".claude", "plugins", "cache");
+  if (existsSync10(cacheBase)) {
+    try {
+      const registries = await readdir3(cacheBase, { withFileTypes: true });
+      for (const reg of registries) {
+        if (!reg.isDirectory())
+          continue;
+        const regDir = join11(cacheBase, reg.name);
+        const plugins = await readdir3(regDir, { withFileTypes: true });
+        for (const plugin of plugins) {
+          if (!plugin.isDirectory())
+            continue;
+          const versionDirs = await readdir3(join11(regDir, plugin.name), { withFileTypes: true });
+          for (const ver of versionDirs) {
+            if (!ver.isDirectory())
+              continue;
+            const mcpPath = join11(regDir, plugin.name, ver.name, ".mcp.json");
+            const flatData = await readJsonSafe(mcpPath);
+            if (flatData) {
+              entries.push(...parseFlatConfig(flatData, "plugin"));
+              break;
+            }
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const entry of entries) {
+    if (seen.has(entry.name))
+      continue;
+    seen.add(entry.name);
+    deduped.push(entry);
+  }
+  return deduped;
+}
+
+// dist/mcp/scan-processes.js
+import { execFileSync as execFileSync4 } from "node:child_process";
+function parsePsOutput(output) {
+  const lines = output.trim().split("\n").slice(1);
+  const entries = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    const match = trimmed.match(/^\s*(\d+)\s+(\S+)\s+(\S+)\s+(\d+)\s+(.+)$/);
+    if (!match)
+      continue;
+    entries.push({
+      pid: parseInt(match[1], 10),
+      tty: match[2],
+      etimeRaw: match[3],
+      rss: parseInt(match[4], 10),
+      args: match[5]
+    });
+  }
+  return entries;
+}
+function parseEtime(etime) {
+  let days = 0;
+  let rest = etime;
+  if (rest.includes("-")) {
+    const [d, r] = rest.split("-");
+    days = parseInt(d, 10);
+    rest = r;
+  }
+  const parts = rest.split(":").map(Number);
+  if (parts.length === 3) {
+    return days * 86400 + parts[0] * 3600 + parts[1] * 60 + parts[2];
+  } else if (parts.length === 2) {
+    return days * 86400 + parts[0] * 60 + parts[1];
+  }
+  return days * 86400 + (parts[0] ?? 0);
+}
+function findProcessesForConfig(config, processes) {
+  if (config.type === "http")
+    return [];
+  const packageName = config.args ? extractPackageName(config.args) : null;
+  const matches = [];
+  for (const proc of processes) {
+    let matched = false;
+    if (packageName && proc.args.includes(packageName)) {
+      matched = true;
+    } else if (config.command === "node" && config.args?.[0]) {
+      if (proc.args.includes(config.args[0])) {
+        matched = true;
+      }
+    }
+    if (matched) {
+      matches.push({
+        pid: proc.pid,
+        tty: proc.tty === "?" ? "" : proc.tty,
+        uptimeSeconds: parseEtime(proc.etimeRaw),
+        memoryMb: Math.round(proc.rss / 1024),
+        commandLine: proc.args
+      });
+    }
+  }
+  return matches;
+}
+function getProcessTable() {
+  try {
+    const output = execFileSync4("ps", ["-eo", "pid,tty,etime,rss,args"], {
+      encoding: "utf-8",
+      timeout: 5e3
+    });
+    return parsePsOutput(output);
+  } catch {
+    return [];
+  }
+}
+
+// dist/commands/mcp-watch.js
+var POLL_INTERVAL_MS = 3e4;
+function checkEnvVars(config) {
+  const required = config.env ? Object.keys(config.env) : [];
+  const missing = required.filter((key) => !process.env[key]);
+  return { required, missing };
+}
+function buildRows(configs) {
+  const processes = getProcessTable();
+  const rows = [];
+  for (const config of configs) {
+    const { required, missing } = checkEnvVars(config);
+    const packageName = config.args ? extractPackageName(config.args) : null;
+    if (config.type === "http") {
+      rows.push({
+        server_name: config.name,
+        config_source: config.source,
+        server_type: "http",
+        command: null,
+        package_name: null,
+        http_url: config.url ?? null,
+        status: "stopped",
+        pid: null,
+        session_tty: null,
+        uptime_seconds: null,
+        memory_mb: null,
+        env_vars_required: required.length ? required : null,
+        env_vars_missing: missing.length ? missing : null,
+        error_detail: "HTTP server \u2014 cannot verify from CLI"
+      });
+      continue;
+    }
+    if (missing.length > 0) {
+      rows.push({
+        server_name: config.name,
+        config_source: config.source,
+        server_type: "stdio",
+        command: config.command ?? null,
+        package_name: packageName,
+        http_url: null,
+        status: "error",
+        pid: null,
+        session_tty: null,
+        uptime_seconds: null,
+        memory_mb: null,
+        env_vars_required: required,
+        env_vars_missing: missing,
+        error_detail: `Missing env: ${missing.join(", ")}`
+      });
+      continue;
+    }
+    const matches = findProcessesForConfig(config, processes);
+    if (matches.length === 0) {
+      rows.push({
+        server_name: config.name,
+        config_source: config.source,
+        server_type: "stdio",
+        command: config.command ?? null,
+        package_name: packageName,
+        http_url: null,
+        status: "stopped",
+        pid: null,
+        session_tty: null,
+        uptime_seconds: null,
+        memory_mb: null,
+        env_vars_required: required.length ? required : null,
+        env_vars_missing: null,
+        error_detail: null
+      });
+    } else {
+      for (const match of matches) {
+        rows.push({
+          server_name: config.name,
+          config_source: config.source,
+          server_type: "stdio",
+          command: config.command ?? null,
+          package_name: packageName,
+          http_url: null,
+          status: "running",
+          pid: match.pid,
+          session_tty: match.tty || null,
+          uptime_seconds: match.uptimeSeconds,
+          memory_mb: match.memoryMb,
+          env_vars_required: required.length ? required : null,
+          env_vars_missing: null,
+          error_detail: null
+        });
+      }
+    }
+  }
+  return rows;
+}
+function printTable(rows, deviceName) {
+  process.stdout.write("\x1B[2J\x1B[H");
+  console.log(chalk18.bold.cyan(`
+  MCP Monitor \u2014 ${deviceName}`));
+  console.log(chalk18.dim(`  ${(/* @__PURE__ */ new Date()).toLocaleTimeString()} \xB7 refreshes every 30s \xB7 Ctrl+C to stop
+`));
+  const running = rows.filter((r) => r.status === "running");
+  const stopped = rows.filter((r) => r.status === "stopped");
+  const errored = rows.filter((r) => r.status === "error");
+  const byTty = /* @__PURE__ */ new Map();
+  for (const r of running) {
+    const key = r.session_tty ?? "unknown";
+    const list = byTty.get(key) ?? [];
+    list.push(r);
+    byTty.set(key, list);
+  }
+  if (byTty.size > 0) {
+    for (const [tty, servers] of byTty) {
+      const totalMem = servers.reduce((sum, s) => sum + (s.memory_mb ?? 0), 0);
+      console.log(chalk18.green(`  Session ${tty}`) + chalk18.dim(` \u2014 ${servers.length} server${servers.length !== 1 ? "s" : ""} \xB7 ${totalMem} MB`));
+      for (const s of servers) {
+        const uptime = formatUptime(s.uptime_seconds ?? 0);
+        console.log(`    ${chalk18.green("\u25CF")} ${s.server_name.padEnd(20)} ${chalk18.dim((s.package_name ?? "").padEnd(30))} ${String(s.memory_mb ?? 0).padStart(4)} MB  ${uptime}`);
+      }
+      console.log("");
+    }
+  }
+  if (stopped.length > 0 || errored.length > 0) {
+    const notRunning = [...stopped, ...errored];
+    console.log(chalk18.yellow(`  Not Running (${notRunning.length})`));
+    for (const s of notRunning) {
+      const icon = s.status === "error" ? chalk18.red("\u2717") : chalk18.yellow("\u25CB");
+      const detail = s.error_detail ? chalk18.dim(` \u2014 ${s.error_detail}`) : "";
+      console.log(`    ${icon} ${s.server_name.padEnd(20)} ${chalk18.dim(s.config_source.padEnd(10))}${detail}`);
+    }
+    console.log("");
+  }
+  if (rows.length === 0) {
+    console.log(chalk18.yellow("  No MCP servers configured."));
+    console.log(chalk18.dim("  Configure servers in ~/.claude/mcp.json or .mcp.json\n"));
+  }
+}
+function formatUptime(seconds) {
+  if (seconds < 60)
+    return `${seconds}s`;
+  if (seconds < 3600)
+    return `${Math.floor(seconds / 60)}m`;
+  const h = Math.floor(seconds / 3600);
+  const m = Math.floor(seconds % 3600 / 60);
+  return `${h}h ${m}m`;
+}
+async function mcpWatchCommand() {
+  const { supabase, userId } = await getAuthenticatedClient();
+  const deviceId = await resolveDeviceId(supabase, userId);
+  const deviceName = detectDeviceName();
+  console.log(chalk18.blue(`Starting MCP monitor for ${deviceName}...`));
+  async function cycle() {
+    const configs = await readAllMcpConfigs();
+    const rows = buildRows(configs);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    await supabase.from("mcp_server_status").delete().eq("device_id", deviceId);
+    if (rows.length > 0) {
+      await supabase.from("mcp_server_status").insert(rows.map((row) => ({
+        device_id: deviceId,
+        ...row,
+        checked_at: now
+      })));
+    }
+    printTable(rows, deviceName);
+  }
+  await cycle();
+  const interval = setInterval(cycle, POLL_INTERVAL_MS);
+  const shutdown = () => {
+    clearInterval(interval);
+    console.log(chalk18.dim("\nMCP monitor stopped."));
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+
 // dist/index.js
 var program = new Command();
 program.name("md4ai").description("MD4AI \u2014 Claude tooling visualiser").version(CURRENT_VERSION).addHelpText("after", `
@@ -2003,6 +2409,7 @@ program.command("print <title>").description("Generate a printable wall-chart HT
 program.command("sync").description("Re-push latest scan data to Supabase").option("--all", "Sync all folders on all devices").action(syncCommand);
 program.command("import <zipfile>").description("Import a Claude setup bundle exported from the web dashboard").action(importBundleCommand);
 program.command("check-update").description("Check if a newer version of md4ai is available").action(checkForUpdate);
+program.command("mcp-watch").description("Monitor MCP server status on this device (runs until Ctrl+C)").action(mcpWatchCommand);
 var admin = program.command("admin").description("Admin commands for managing the tools registry");
 admin.command("update-tool").description("Add or update a tool in the master registry").requiredOption("--name <name>", "Canonical tool name (e.g. next, playwright)").option("--display <display>", 'Human-friendly display name (e.g. "Next.js")').option("--category <category>", "Tool category (framework|runtime|cli|mcp|package|database|other)").option("--stable <version>", "Latest stable version").option("--beta <version>", "Latest beta/RC version").option("--source <url>", "Source of truth URL for checking versions").option("--install <url>", "Download/install link").option("--notes <text>", "Compatibility notes or warnings").action(adminUpdateToolCommand);
 admin.command("list-tools").description("List all tools in the master registry").action(adminListToolsCommand);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "md4ai",
-  "version": "0.5.2",
+  "version": "0.6.1",
   "description": "CLI for MD4AI — scan Claude projects and sync to your dashboard",
   "type": "module",
   "bin": {