agentseal 0.9.0 → 0.9.2

package/dist/chunk-I6AROGUC.js

@@ -0,0 +1,580 @@
+#!/usr/bin/env node
+import {
+  AgentCollector,
+  appdata,
+  collectSkillDirs,
+  collectSkillFiles,
+  extractMcpServers,
+  home,
+  isDir,
+  isFile,
+  makeAgent,
+  platformPath,
+  readConfig,
+  registerCollector
+} from "./chunk-2WEF3SNR.js";
+import {
+  createMCPServerConfig
+} from "./chunk-4EOVMNW5.js";
+
+// src/guard/collectors/claude-desktop.ts
+import { dirname } from "path";
+var ClaudeDesktopCollector = class extends AgentCollector {
+  name = "Claude Desktop";
+  collect() {
+    const configPath = platformPath({
+      Darwin: home("Library", "Application Support", "Claude", "claude_desktop_config.json"),
+      Windows: appdata("Claude", "claude_desktop_config.json"),
+      Linux: home(".config", "Claude", "claude_desktop_config.json")
+    });
+    if (!configPath) return [];
+    if (!isFile(configPath)) {
+      return [
+        makeAgent(
+          this.name,
+          "claude-desktop",
+          configPath,
+          [],
+          [],
+          isDir(dirname(configPath)) ? "installed_no_config" : "not_installed"
+        )
+      ];
+    }
+    const data = readConfig(configPath);
+    if (!data) {
+      return [makeAgent(this.name, "claude-desktop", configPath, [], [], "error")];
+    }
+    const servers = extractMcpServers(data, configPath, "claude-desktop");
+    return [makeAgent(this.name, "claude-desktop", configPath, servers, [], "found")];
+  }
+};
+registerCollector(new ClaudeDesktopCollector());
+
+// src/guard/collectors/claude-code.ts
+var ClaudeCodeCollector = class extends AgentCollector {
+  name = "Claude Code";
+  collect() {
+    const candidates = [home(".claude.json"), home(".claude", "settings.json")];
+    const configPath = candidates.find(isFile);
+    if (!configPath) {
+      const dirExists = isDir(home(".claude"));
+      return [
+        makeAgent(
+          this.name,
+          "claude-code",
+          candidates[0],
+          [],
+          [],
+          dirExists ? "installed_no_config" : "not_installed"
+        )
+      ];
+    }
+    const data = readConfig(configPath);
+    if (!data) {
+      return [makeAgent(this.name, "claude-code", configPath, [], [], "error")];
+    }
+    const servers = extractMcpServers(data, configPath, "claude-code");
+    const skills = collectSkillFiles([home(".claude", "CLAUDE.md")]);
+    return [makeAgent(this.name, "claude-code", configPath, servers, skills, "found")];
+  }
+};
+registerCollector(new ClaudeCodeCollector());
+
+// src/guard/collectors/cursor.ts
+var CursorCollector = class extends AgentCollector {
+  name = "Cursor";
+  collect() {
+    const configPath = home(".cursor", "mcp.json");
+    if (!isFile(configPath)) {
+      return [
+        makeAgent(
+          this.name,
+          "cursor",
+          configPath,
+          [],
+          [],
+          isDir(home(".cursor")) ? "installed_no_config" : "not_installed"
+        )
+      ];
+    }
+    const data = readConfig(configPath);
+    if (!data) {
+      return [makeAgent(this.name, "cursor", configPath, [], [], "error")];
+    }
+    const servers = extractMcpServers(data, configPath, "cursor");
+    const skills = [
+      ...collectSkillFiles([home(".cursorrules")]),
+      ...collectSkillDirs([home(".cursor", "rules")])
+    ];
+    return [makeAgent(this.name, "cursor", configPath, servers, skills, "found")];
+  }
+};
+registerCollector(new CursorCollector());
+
+// src/guard/collectors/vscode.ts
+import { dirname as dirname2 } from "path";
+var VSCodeCollector = class extends AgentCollector {
+  name = "VS Code";
+  collect() {
+    const configPath = platformPath({
+      Darwin: home("Library", "Application Support", "Code", "User", "mcp.json"),
+      Windows: appdata("Code", "User", "mcp.json"),
+      Linux: home(".config", "Code", "User", "mcp.json")
+    });
+    if (!configPath) return [];
+    if (!isFile(configPath)) {
+      return [
+        makeAgent(
+          this.name,
+          "vscode",
+          configPath,
+          [],
+          [],
+          isDir(dirname2(configPath)) ? "installed_no_config" : "not_installed"
+        )
+      ];
+    }
+    const data = readConfig(configPath, "jsonc");
+    if (!data) {
+      return [makeAgent(this.name, "vscode", configPath, [], [], "error")];
+    }
+    const servers = extractMcpServers(data, configPath, "vscode", "servers");
+    const skills = collectSkillFiles([home(".github", "copilot-instructions.md")]);
+    return [makeAgent(this.name, "vscode", configPath, servers, skills, "found")];
+  }
+};
+registerCollector(new VSCodeCollector());
+
+// src/guard/collectors/windsurf.ts
+var WindsurfCollector = class extends AgentCollector {
+  name = "Windsurf";
+  collect() {
+    const configPath = home(".codeium", "windsurf", "mcp_config.json");
+    if (!isFile(configPath)) {
+      return [
+        makeAgent(
+          this.name,
+          "windsurf",
+          configPath,
+          [],
+          [],
+          isDir(home(".codeium", "windsurf")) ? "installed_no_config" : "not_installed"
+        )
+      ];
+    }
+    const data = readConfig(configPath);
+    if (!data) {
+      return [makeAgent(this.name, "windsurf", configPath, [], [], "error")];
+    }
+    const servers = extractMcpServers(data, configPath, "windsurf");
+    const skills = collectSkillFiles([home(".windsurfrules")]);
+    return [makeAgent(this.name, "windsurf", configPath, servers, skills, "found")];
+  }
+};
+registerCollector(new WindsurfCollector());
+
+// src/guard/collectors/cline.ts
+import { dirname as dirname3 } from "path";
+var VARIANTS = [
+  {
+    name: "Cline",
+    agentType: "cline",
+    extensionId: "saoudrizwan.claude-dev",
+    skillFile: ".clinerules"
+  },
+  {
+    name: "Roo Code",
+    agentType: "roo-code",
+    extensionId: "rooveterinaryinc.roo-cline"
+  },
+  {
+    name: "Kilo Code",
+    agentType: "kilo-code",
+    extensionId: "kilocode.kilo"
+  }
+];
+function vsCodeGlobalStoragePath(extensionId, filename) {
+  const sub = ["globalStorage", extensionId, "settings", filename];
+  return {
+    Darwin: home("Library", "Application Support", "Code", "User", ...sub),
+    Windows: appdata("Code", "User", ...sub),
+    Linux: home(".config", "Code", "User", ...sub)
+  };
+}
+var ClineCollector = class extends AgentCollector {
+  name = "Cline/Roo/Kilo";
+  collect() {
+    const results = [];
+    for (const variant of VARIANTS) {
+      const filename = variant.agentType === "cline" ? "cline_mcp_settings.json" : "mcp_settings.json";
+      const paths = vsCodeGlobalStoragePath(variant.extensionId, filename);
+      const configPath = platformPath(paths);
+      if (!configPath) continue;
+      if (!isFile(configPath)) {
+        results.push(
+          makeAgent(
+            variant.name,
+            variant.agentType,
+            configPath,
+            [],
+            [],
+            isDir(dirname3(configPath)) ? "installed_no_config" : "not_installed"
+          )
+        );
+        continue;
+      }
+      const data = readConfig(configPath);
+      if (!data) {
+        results.push(makeAgent(variant.name, variant.agentType, configPath, [], [], "error"));
+        continue;
+      }
+      const servers = extractMcpServers(data, configPath, variant.agentType);
+      const skills = variant.skillFile ? collectSkillFiles([home(variant.skillFile)]) : [];
+      results.push(
+        makeAgent(variant.name, variant.agentType, configPath, servers, skills, "found")
+      );
+    }
+    return results;
+  }
+};
+registerCollector(new ClineCollector());
+
+// src/guard/collectors/codex.ts
+var CodexCollector = class extends AgentCollector {
+  name = "Codex CLI";
+  collect() {
+    const configPath = home(".codex", "config.json");
+    if (!isFile(configPath)) {
+      return [
+        makeAgent(
+          this.name,
+          "codex",
+          configPath,
+          [],
+          [],
+          isDir(home(".codex")) ? "installed_no_config" : "not_installed"
+        )
+      ];
+    }
+    const data = readConfig(configPath);
+    if (!data) {
+      return [makeAgent(this.name, "codex", configPath, [], [], "error")];
+    }
+    const servers = extractMcpServers(data, configPath, "codex", "mcp_servers");
+    return [makeAgent(this.name, "codex", configPath, servers, [], "found")];
+  }
+};
+registerCollector(new CodexCollector());
+
+// src/guard/collectors/gemini.ts
+var GeminiCollector = class extends AgentCollector {
+  name = "Gemini CLI";
+  collect() {
+    const configPath = home(".gemini", "settings.json");
+    if (!isFile(configPath)) {
+      return [
+        makeAgent(
+          this.name,
+          "gemini-cli",
+          configPath,
+          [],
+          [],
+          isDir(home(".gemini")) ? "installed_no_config" : "not_installed"
+        )
+      ];
+    }
+    const data = readConfig(configPath);
+    if (!data) {
+      return [makeAgent(this.name, "gemini-cli", configPath, [], [], "error")];
+    }
+    const servers = extractMcpServers(data, configPath, "gemini-cli");
+    const skills = collectSkillFiles([home("GEMINI.md")]);
+    return [makeAgent(this.name, "gemini-cli", configPath, servers, skills, "found")];
+  }
+};
+registerCollector(new GeminiCollector());
+
+// src/guard/collectors/zed.ts
+import { dirname as dirname4 } from "path";
+var ZedCollector = class extends AgentCollector {
+  name = "Zed";
+  collect() {
+    const configPath = platformPath({
+      Darwin: home(".zed", "settings.json"),
+      Linux: home(".config", "zed", "settings.json"),
+      Windows: appdata("Zed", "settings.json")
+    });
+    if (!configPath) return [];
+    if (!isFile(configPath)) {
+      return [
+        makeAgent(
+          this.name,
+          "zed",
+          configPath,
+          [],
+          [],
+          isDir(dirname4(configPath)) ? "installed_no_config" : "not_installed"
+        )
+      ];
+    }
+    const data = readConfig(configPath, "jsonc");
+    if (!data) {
+      return [makeAgent(this.name, "zed", configPath, [], [], "error")];
+    }
+    const servers = extractMcpServers(data, configPath, "zed", "context_servers");
+    return [makeAgent(this.name, "zed", configPath, servers, [], "found")];
+  }
+};
+registerCollector(new ZedCollector());
+
+// src/guard/collectors/continue-dev.ts
+var ContinueCollector = class extends AgentCollector {
+  name = "Continue";
+  collect() {
+    const configPath = home(".continue", "config.json");
+    if (!isFile(configPath)) {
+      return [
+        makeAgent(
+          this.name,
+          "continue",
+          configPath,
+          [],
+          [],
+          isDir(home(".continue")) ? "installed_no_config" : "not_installed"
+        )
+      ];
+    }
+    const data = readConfig(configPath);
+    if (!data) {
+      return [makeAgent(this.name, "continue", configPath, [], [], "error")];
+    }
+    const servers = extractMcpServers(data, configPath, "continue");
+    const skills = collectSkillDirs([home(".continue", "rules")]);
+    return [makeAgent(this.name, "continue", configPath, servers, skills, "found")];
+  }
+};
+registerCollector(new ContinueCollector());
+
+// src/guard/collectors/pi-code.ts
+var PiCodeCollector = class extends AgentCollector {
+  name = "Pi Code";
+  collect() {
+    const configPath = home(".pi", "agent", "config.json");
+    if (!isFile(configPath)) {
+      return [
+        makeAgent(
+          this.name,
+          "pi-code",
+          configPath,
+          [],
+          [],
+          isDir(home(".pi", "agent")) ? "installed_no_config" : "not_installed"
+        )
+      ];
+    }
+    const data = readConfig(configPath);
+    if (!data) {
+      return [makeAgent(this.name, "pi-code", configPath, [], [], "error")];
+    }
+    const servers = extractMcpServers(data, configPath, "pi-code");
+    const skills = collectSkillDirs([home(".pi", "agent", "extensions")]);
+    return [makeAgent(this.name, "pi-code", configPath, servers, skills, "found")];
+  }
+};
+registerCollector(new PiCodeCollector());
+
+// src/guard/collectors/generic.ts
+import { dirname as dirname5 } from "path";
+function defs() {
+  return [
+    {
+      name: "Aider",
+      agentType: "aider",
+      paths: { all: home(".aider.conf.yml") },
+      mcpKey: ""
+    },
+    {
+      name: "Goose",
+      agentType: "goose",
+      paths: {
+        Darwin: home(".config", "goose", "config.yaml"),
+        Linux: home(".config", "goose", "config.yaml")
+      },
+      mcpKey: "extensions",
+      format: "yaml"
+    },
+    {
+      name: "Amazon Q",
+      agentType: "amazon-q",
+      paths: { all: home(".aws", "amazonq", "mcp.json") },
+      mcpKey: "mcpServers"
+    },
+    {
+      name: "Copilot CLI",
+      agentType: "copilot-cli",
+      paths: { all: home(".copilot", "mcp-config.json") },
+      mcpKey: "mcpServers"
+    },
+    {
+      name: "Amp",
+      agentType: "amp",
+      paths: {
+        Darwin: home(".config", "amp", "settings.json"),
+        Linux: home(".config", "amp", "settings.json"),
+        Windows: appdata("amp", "settings.json")
+      },
+      mcpKey: "amp.mcpServers"
+    },
+    {
+      name: "Junie",
+      agentType: "junie",
+      paths: { all: home(".junie", "mcp", "mcp.json") },
+      mcpKey: "mcpServers"
+    },
+    {
+      name: "Kiro",
+      agentType: "kiro",
+      paths: { all: home(".kiro", "settings", "mcp.json") },
+      mcpKey: "mcpServers"
+    },
+    {
+      name: "OpenCode",
+      agentType: "opencode",
+      paths: {
+        Darwin: home(".config", "opencode", "opencode.json"),
+        Linux: home(".config", "opencode", "opencode.json"),
+        Windows: appdata("opencode", "opencode.json")
+      },
+      mcpKey: "mcp"
+    },
+    {
+      name: "OpenClaw",
+      agentType: "openclaw",
+      paths: { all: home(".openclaw", "openclaw.json") },
+      mcpKey: "mcpServers",
+      format: "jsonc"
+    },
+    {
+      name: "Crush",
+      agentType: "crush",
+      paths: { all: home(".config", "crush", "crush.json") },
+      mcpKey: "mcp"
+    },
+    {
+      name: "Qwen Code",
+      agentType: "qwen-code",
+      paths: { all: home(".qwen", "settings.json") },
+      mcpKey: "mcpServers"
+    },
+    {
+      name: "Grok CLI",
+      agentType: "grok-cli",
+      paths: { all: home(".grok", "user-settings.json") },
+      mcpKey: "mcpServers"
+    },
+    {
+      name: "Kimi CLI",
+      agentType: "kimi-cli",
+      paths: { all: home(".kimi", "mcp.json") },
+      mcpKey: "mcpServers"
+    },
+    {
+      name: "Trae",
+      agentType: "trae",
+      paths: {
+        Darwin: home("Library", "Application Support", "Trae", "mcp_config.json"),
+        Linux: home(".config", "Trae", "mcp_config.json")
+      },
+      mcpKey: "mcpServers"
+    },
+    {
+      name: "MaxClaw",
+      agentType: "maxclaw",
+      paths: { all: home(".maxclaw", "config.json") },
+      mcpKey: "mcpServers"
+    }
+  ];
+}
+var GenericCollector = class extends AgentCollector {
+  name = "Generic";
+  collect() {
+    const results = [];
+    for (const def of defs()) {
+      const configPath = platformPath(def.paths);
+      if (!configPath) continue;
+      if (!isFile(configPath)) {
+        results.push(
+          makeAgent(
+            def.name,
+            def.agentType,
+            configPath,
+            [],
+            [],
+            isDir(dirname5(configPath)) ? "installed_no_config" : "not_installed"
+          )
+        );
+        continue;
+      }
+      if (def.format === "yaml" || def.format === "toml" || !def.mcpKey) {
+        results.push(makeAgent(def.name, def.agentType, configPath, [], [], "found"));
+        continue;
+      }
+      const data = readConfig(configPath, def.format === "jsonc" ? "jsonc" : null);
+      if (!data) {
+        results.push(makeAgent(def.name, def.agentType, configPath, [], [], "error"));
+        continue;
+      }
+      const servers = extractMcpServers(data, configPath, def.agentType, def.mcpKey);
+      results.push(makeAgent(def.name, def.agentType, configPath, servers, [], "found"));
+    }
+    return results;
+  }
+};
+registerCollector(new GenericCollector());
+
+// src/guard/collectors/process.ts
+import { execSync } from "child_process";
+var MCP_PATTERNS = [
+  { pattern: /\bnpx\b.*\b(@modelcontextprotocol\/server-[\w-]+|mcp-server-[\w-]+)\b/i, prefix: "npx" },
+  { pattern: /\buvx\b.*\b(mcp-server-[\w-]+)\b/i, prefix: "uvx" },
+  { pattern: /\bnode\b.*\b(mcp-server-[\w-]+|@modelcontextprotocol\/server-[\w-]+)\b/i, prefix: "node" },
+  { pattern: /\bpython[3]?\b.*\b(mcp[_-]server[_-][\w-]+)\b/i, prefix: "python" },
+  { pattern: /\bdeno\b.*\b(mcp-server-[\w-]+)\b/i, prefix: "deno" },
+  { pattern: /\bbun\b.*\b(mcp-server-[\w-]+)\b/i, prefix: "bun" }
+];
+var ProcessCollector = class extends AgentCollector {
+  name = "Process";
+  collect() {
+    let psOutput;
+    try {
+      psOutput = execSync("ps aux", { encoding: "utf-8", timeout: 5e3 });
+    } catch {
+      return [];
+    }
+    const servers = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const line of psOutput.split("\n")) {
+      for (const { pattern, prefix } of MCP_PATTERNS) {
+        const match = pattern.exec(line);
+        if (!match) continue;
+        const serverName = match[1] ?? `${prefix}-unknown`;
+        if (seen.has(serverName)) continue;
+        seen.add(serverName);
+        servers.push(
+          createMCPServerConfig({
+            name: serverName,
+            command: prefix,
+            args: [serverName],
+            agents: ["process"],
+            sourceFile: "process:ps"
+          })
+        );
+      }
+    }
+    if (servers.length === 0) return [];
+    return [
+      makeAgent("Running Processes", "process", "ps:aux", servers, [], "found")
+    ];
+  }
+};
+registerCollector(new ProcessCollector());