agentseal 0.6.0 → 0.8.1

package/dist/chunk-23GC7G5P.js

@@ -0,0 +1,635 @@
+#!/usr/bin/env node
+import {
+  __esm,
+  __export
+} from "./chunk-ZLRN7Q7C.js";
+
+// src/machine-discovery.ts
+var machine_discovery_exports = {};
+__export(machine_discovery_exports, {
+  PROJECT_MCP_CONFIGS: () => PROJECT_MCP_CONFIGS,
+  PROJECT_SKILL_DIRS: () => PROJECT_SKILL_DIRS,
+  PROJECT_SKILL_FILES: () => PROJECT_SKILL_FILES,
+  getWellKnownConfigs: () => getWellKnownConfigs,
+  scanDirectory: () => scanDirectory,
+  scanMachine: () => scanMachine,
+  stripJsonComments: () => stripJsonComments
+});
+import { readdirSync, readFileSync, statSync } from "fs";
+import { homedir } from "os";
+import { dirname, join, resolve } from "path";
+function getWellKnownConfigs() {
+  const home = homedir();
+  const appdata = process.platform === "win32" ? process.env.APPDATA ?? "" : null;
+  const p = (...parts) => join(home, ...parts);
+  const ap = (...parts) => appdata ? join(appdata, ...parts) : null;
+  const sys = process.platform === "darwin" ? "Darwin" : process.platform === "win32" ? "Windows" : "Linux";
+  const configs = [
+    {
+      name: "Claude Desktop",
+      agent_type: "claude-desktop",
+      paths: {
+        Darwin: p("Library", "Application Support", "Claude", "claude_desktop_config.json"),
+        Windows: ap("Claude", "claude_desktop_config.json"),
+        Linux: p(".config", "Claude", "claude_desktop_config.json")
+      },
+      mcp_key: "mcpServers"
+    },
+    {
+      name: "Claude Code",
+      agent_type: "claude-code",
+      paths: { all: p(".claude.json") },
+      mcp_key: "mcpServers"
+    },
+    {
+      name: "Cursor",
+      agent_type: "cursor",
+      paths: { all: p(".cursor", "mcp.json") },
+      mcp_key: "mcpServers"
+    },
+    {
+      name: "Windsurf",
+      agent_type: "windsurf",
+      paths: {
+        Darwin: p(".codeium", "windsurf", "mcp_config.json"),
+        Windows: p(".codeium", "windsurf", "mcp_config.json"),
+        Linux: p(".codeium", "windsurf", "mcp_config.json")
+      },
+      mcp_key: "mcpServers"
+    },
+    {
+      name: "VS Code",
+      agent_type: "vscode",
+      paths: {
+        Darwin: p("Library", "Application Support", "Code", "User", "mcp.json"),
+        Windows: ap("Code", "User", "mcp.json"),
+        Linux: p(".config", "Code", "User", "mcp.json")
+      },
+      mcp_key: "servers",
+      format: "jsonc"
+    },
+    {
+      name: "Gemini CLI",
+      agent_type: "gemini-cli",
+      paths: { all: p(".gemini", "settings.json") },
+      mcp_key: "mcpServers"
+    },
+    {
+      name: "Codex CLI",
+      agent_type: "codex",
+      paths: { all: p(".codex", "config.toml") },
+      mcp_key: "mcp_servers",
+      format: "toml"
+    },
+    {
+      name: "OpenClaw",
+      agent_type: "openclaw",
+      paths: { all: p(".openclaw", "openclaw.json") },
+      mcp_key: "mcpServers",
+      format: "jsonc"
+    },
+    {
+      name: "Kiro",
+      agent_type: "kiro",
+      paths: { all: p(".kiro", "settings", "mcp.json") },
+      mcp_key: "mcpServers"
+    },
+    {
+      name: "OpenCode",
+      agent_type: "opencode",
+      paths: {
+        Darwin: p(".config", "opencode", "opencode.json"),
+        Linux: p(".config", "opencode", "opencode.json"),
+        Windows: ap("opencode", "opencode.json")
+      },
+      mcp_key: "mcp"
+    },
+    {
+      name: "Continue",
+      agent_type: "continue",
+      paths: { all: p(".continue", "config.yaml") },
+      mcp_key: "mcpServers",
+      format: "yaml"
+    },
+    {
+      name: "Cline",
+      agent_type: "cline",
+      paths: {
+        Darwin: p("Library", "Application Support", "Code", "User", "globalStorage", "saoudrizwan.claude-dev", "settings", "cline_mcp_settings.json"),
+        Windows: ap("Code", "User", "globalStorage", "saoudrizwan.claude-dev", "settings", "cline_mcp_settings.json"),
+        Linux: p(".config", "Code", "User", "globalStorage", "saoudrizwan.claude-dev", "settings", "cline_mcp_settings.json")
+      },
+      mcp_key: "mcpServers"
+    },
+    {
+      name: "Roo Code",
+      agent_type: "roo-code",
+      paths: {
+        Darwin: p("Library", "Application Support", "Code", "User", "globalStorage", "rooveterinaryinc.roo-cline", "settings", "mcp_settings.json"),
+        Windows: ap("Code", "User", "globalStorage", "rooveterinaryinc.roo-cline", "settings", "mcp_settings.json"),
+        Linux: p(".config", "Code", "User", "globalStorage", "rooveterinaryinc.roo-cline", "settings", "mcp_settings.json")
+      },
+      mcp_key: "mcpServers"
+    },
+    {
+      name: "Kilo Code",
+      agent_type: "kilo-code",
+      paths: {
+        Darwin: p("Library", "Application Support", "Code", "User", "globalStorage", "kilocode.kilo", "mcp_settings.json"),
+        Windows: ap("Code", "User", "globalStorage", "kilocode.kilo", "mcp_settings.json"),
+        Linux: p(".config", "Code", "User", "globalStorage", "kilocode.kilo", "mcp_settings.json")
+      },
+      mcp_key: "mcpServers"
+    },
+    {
+      name: "Zed",
+      agent_type: "zed",
+      paths: {
+        Darwin: p(".zed", "settings.json"),
+        Linux: p(".config", "zed", "settings.json"),
+        Windows: ap("Zed", "settings.json")
+      },
+      mcp_key: "context_servers",
+      format: "jsonc"
+    },
+    {
+      name: "Amp",
+      agent_type: "amp",
+      paths: {
+        Darwin: p(".config", "amp", "settings.json"),
+        Linux: p(".config", "amp", "settings.json"),
+        Windows: ap("amp", "settings.json")
+      },
+      mcp_key: "amp.mcpServers"
+    },
+    {
+      name: "Aider",
+      agent_type: "aider",
+      paths: { all: p(".aider.conf.yml") },
+      mcp_key: null
+    },
+    {
+      name: "Amazon Q",
+      agent_type: "amazon-q",
+      paths: { all: p(".aws", "amazonq", "mcp.json") },
+      mcp_key: "mcpServers"
+    },
+    {
+      name: "Copilot CLI",
+      agent_type: "copilot-cli",
+      paths: { all: p(".copilot", "mcp-config.json") },
+      mcp_key: "mcpServers"
+    },
+    {
+      name: "Junie",
+      agent_type: "junie",
+      paths: { all: p(".junie", "mcp", "mcp.json") },
+      mcp_key: "mcpServers"
+    },
+    {
+      name: "Goose",
+      agent_type: "goose",
+      paths: {
+        Darwin: p(".config", "goose", "config.yaml"),
+        Linux: p(".config", "goose", "config.yaml")
+      },
+      mcp_key: "extensions",
+      format: "yaml"
+    },
+    {
+      name: "Crush",
+      agent_type: "crush",
+      paths: { all: p(".config", "crush", "crush.json") },
+      mcp_key: "mcp"
+    },
+    {
+      name: "Qwen Code",
+      agent_type: "qwen-code",
+      paths: { all: p(".qwen", "settings.json") },
+      mcp_key: "mcpServers"
+    },
+    {
+      name: "Grok CLI",
+      agent_type: "grok-cli",
+      paths: { all: p(".grok", "user-settings.json") },
+      mcp_key: "mcpServers"
+    },
+    {
+      name: "Visual Studio",
+      agent_type: "visual-studio",
+      paths: { Windows: p(".mcp.json") },
+      mcp_key: "servers"
+    },
+    {
+      name: "Kimi CLI",
+      agent_type: "kimi-cli",
+      paths: { all: p(".kimi", "mcp.json") },
+      mcp_key: "mcpServers"
+    },
+    {
+      name: "Trae",
+      agent_type: "trae",
+      paths: {
+        Darwin: p("Library", "Application Support", "Trae", "mcp_config.json"),
+        Linux: p(".config", "Trae", "mcp_config.json")
+      },
+      mcp_key: "mcpServers"
+    },
+    {
+      name: "MaxClaw",
+      agent_type: "maxclaw",
+      paths: { all: p(".maxclaw", "config.json") },
+      mcp_key: "mcpServers"
+    }
+  ];
+  return configs.map((cfg) => ({
+    ...cfg,
+    paths: Object.fromEntries(
+      Object.entries(cfg.paths).filter(([, v]) => v !== null)
+    )
+  }));
+}
+function stripJsonComments(text) {
+  const result = [];
+  let i = 0;
+  const n = text.length;
+  while (i < n) {
+    if (text[i] === '"') {
+      let j = i + 1;
+      while (j < n) {
+        if (text[j] === "\\") {
+          j += 2;
+        } else if (text[j] === '"') {
+          j += 1;
+          break;
+        } else {
+          j += 1;
+        }
+      }
+      result.push(text.slice(i, j));
+      i = j;
+    } else if (text.slice(i, i + 2) === "//") {
+      while (i < n && text[i] !== "\n") i++;
+    } else if (text.slice(i, i + 2) === "/*") {
+      i += 2;
+      while (i < n - 1 && text.slice(i, i + 2) !== "*/") i++;
+      if (i < n - 1) i += 2;
+    } else {
+      result.push(text[i]);
+      i += 1;
+    }
+  }
+  return result.join("");
+}
+function isFile(p) {
+  try {
+    return statSync(p).isFile();
+  } catch {
+    return false;
+  }
+}
+function isDir(p) {
+  try {
+    return statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function rglob(dir, patterns) {
+  const results = [];
+  const _walk = (d) => {
+    let entries;
+    try {
+      entries = readdirSync(d);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const full = join(d, entry);
+      try {
+        const st = statSync(full);
+        if (st.isDirectory()) {
+          _walk(full);
+        } else if (st.isFile()) {
+          for (const pat of patterns) {
+            if (pat === "*.md" && entry.endsWith(".md")) {
+              results.push(full);
+              break;
+            } else if (pat === "SKILL.md" && entry === "SKILL.md") {
+              results.push(full);
+              break;
+            } else if (entry === pat) {
+              results.push(full);
+              break;
+            }
+          }
+        }
+      } catch {
+        continue;
+      }
+    }
+  };
+  _walk(dir);
+  return results;
+}
+function globPrefix(dir, prefix) {
+  try {
+    return readdirSync(dir).filter((f) => f.startsWith(prefix)).map((f) => join(dir, f)).filter((f) => isFile(f));
+  } catch {
+    return [];
+  }
+}
+function readJsonSafe(path, format) {
+  try {
+    let raw = readFileSync(path, "utf-8");
+    if (format === "jsonc") {
+      raw = stripJsonComments(raw);
+    }
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function extractMCPServers(data, mcpKey, sourceFile, agentType) {
+  if (mcpKey === null) return [];
+  let servers;
+  if (mcpKey.includes(".")) {
+    const parts = mcpKey.split(".");
+    let node = data;
+    for (const part of parts) {
+      node = node && typeof node === "object" ? node[part] : void 0;
+    }
+    servers = node ?? {};
+  } else {
+    servers = data[mcpKey] ?? {};
+  }
+  const results = [];
+  if (typeof servers === "object" && servers !== null && !Array.isArray(servers)) {
+    for (const [srvName, srvCfg] of Object.entries(servers)) {
+      if (typeof srvCfg !== "object" || srvCfg === null) continue;
+      const normalized = { ...srvCfg };
+      if ("cmd" in normalized && !("command" in normalized)) {
+        normalized.command = normalized.cmd;
+        delete normalized.cmd;
+      }
+      if ("envs" in normalized && !("env" in normalized)) {
+        normalized.env = normalized.envs;
+        delete normalized.envs;
+      }
+      results.push({
+        name: srvName,
+        source_file: sourceFile,
+        agent_type: agentType,
+        ...normalized
+      });
+    }
+  }
+  return results;
+}
+function scanMachine() {
+  const sys = process.platform === "darwin" ? "Darwin" : process.platform === "win32" ? "Windows" : "Linux";
+  const home = homedir();
+  const configs = getWellKnownConfigs();
+  const agents = [];
+  const allMCPServers = [];
+  const allSkillPaths = [];
+  const seenSkillPaths = /* @__PURE__ */ new Set();
+  for (const cfg of configs) {
+    const path = cfg.paths[sys] ?? cfg.paths["all"] ?? null;
+    if (path === null) continue;
+    if (!isFile(path)) {
+      const dir = dirname(path);
+      if (isDir(dir)) {
+        agents.push({
+          name: cfg.name,
+          config_path: dir,
+          agent_type: cfg.agent_type,
+          mcp_servers: 0,
+          skills_count: 0,
+          status: "installed_no_config"
+        });
+      } else {
+        agents.push({
+          name: cfg.name,
+          config_path: path,
+          agent_type: cfg.agent_type,
+          mcp_servers: 0,
+          skills_count: 0,
+          status: "not_installed"
+        });
+      }
+      continue;
+    }
+    if (cfg.format === "yaml" || cfg.format === "toml") {
+      agents.push({
+        name: cfg.name,
+        config_path: path,
+        agent_type: cfg.agent_type,
+        mcp_servers: 0,
+        skills_count: 0,
+        status: "found"
+      });
+      continue;
+    }
+    const data = readJsonSafe(path, cfg.format);
+    if (data === null) {
+      agents.push({
+        name: cfg.name,
+        config_path: path,
+        agent_type: cfg.agent_type,
+        mcp_servers: 0,
+        skills_count: 0,
+        status: "error"
+      });
+      continue;
+    }
+    const servers = extractMCPServers(data, cfg.mcp_key, path, cfg.agent_type);
+    allMCPServers.push(...servers);
+    agents.push({
+      name: cfg.name,
+      config_path: path,
+      agent_type: cfg.agent_type,
+      mcp_servers: servers.length,
+      skills_count: 0,
+      status: "found"
+    });
+  }
+  for (const skillDirRel of SKILL_DIRS) {
+    const skillDir = join(home, skillDirRel);
+    if (isDir(skillDir)) {
+      for (const f of rglob(skillDir, ["SKILL.md", "*.md"])) {
+        try {
+          if (statSync(f).size > MAX_SKILL_SIZE) continue;
+        } catch {
+          continue;
+        }
+        const resolved = resolve(f);
+        if (!seenSkillPaths.has(resolved)) {
+          seenSkillPaths.add(resolved);
+          allSkillPaths.push(f);
+        }
+      }
+    }
+  }
+  for (const skillFileRel of SKILL_FILES) {
+    const skillFile = join(home, skillFileRel);
+    if (isFile(skillFile)) {
+      const resolved = resolve(skillFile);
+      if (!seenSkillPaths.has(resolved)) {
+        seenSkillPaths.add(resolved);
+        allSkillPaths.push(skillFile);
+      }
+    }
+  }
+  let cwd;
+  try {
+    cwd = process.cwd();
+  } catch {
+    cwd = null;
+  }
+  if (cwd) {
+    _scanProjectDir(cwd, allMCPServers, allSkillPaths, seenSkillPaths);
+  }
+  const seenServers = /* @__PURE__ */ new Set();
+  const uniqueServers = [];
+  for (const srv of allMCPServers) {
+    const cmd = srv.command ?? srv.url ?? "";
+    const id = Array.isArray(cmd) ? cmd.join(" ") : String(cmd);
+    const key = `${srv.name}::${id}`;
+    if (!seenServers.has(key)) {
+      seenServers.add(key);
+      uniqueServers.push(srv);
+    }
+  }
+  return { agents, mcpServers: uniqueServers, skillPaths: allSkillPaths };
+}
+function scanDirectory(directory) {
+  const dir = resolve(directory);
+  if (!isDir(dir)) return { agents: [], mcpServers: [], skillPaths: [] };
+  const mcpServers = [];
+  const skillPaths = [];
+  const seenSkillPaths = /* @__PURE__ */ new Set();
+  _scanProjectDir(dir, mcpServers, skillPaths, seenSkillPaths);
+  return { agents: [], mcpServers, skillPaths };
+}
+function _scanProjectDir(dir, mcpServers, skillPaths, seenSkillPaths) {
+  for (const [relPath, mcpKey, fmt] of PROJECT_MCP_CONFIGS) {
+    const mcpFile = join(dir, relPath);
+    if (!isFile(mcpFile)) continue;
+    const data = readJsonSafe(mcpFile, fmt);
+    if (data === null) continue;
+    const servers = data[mcpKey];
+    if (typeof servers === "object" && servers !== null && !Array.isArray(servers)) {
+      for (const [srvName, srvCfg] of Object.entries(servers)) {
+        if (typeof srvCfg !== "object" || srvCfg === null) continue;
+        mcpServers.push({
+          name: srvName,
+          source_file: mcpFile,
+          agent_type: "project",
+          ...srvCfg
+        });
+      }
+    }
+  }
+  for (const skillFileRel of PROJECT_SKILL_FILES) {
+    const candidate = join(dir, skillFileRel);
+    if (isFile(candidate)) {
+      const resolved = resolve(candidate);
+      if (!seenSkillPaths.has(resolved)) {
+        seenSkillPaths.add(resolved);
+        skillPaths.push(candidate);
+      }
+    }
+  }
+  for (const f of globPrefix(dir, ".clinerules-")) {
+    const resolved = resolve(f);
+    if (!seenSkillPaths.has(resolved)) {
+      seenSkillPaths.add(resolved);
+      skillPaths.push(f);
+    }
+  }
+  for (const skillDirRel of PROJECT_SKILL_DIRS) {
+    const skillDir = join(dir, skillDirRel);
+    if (isDir(skillDir)) {
+      for (const f of rglob(skillDir, ["*.md"])) {
+        const resolved = resolve(f);
+        if (!seenSkillPaths.has(resolved)) {
+          seenSkillPaths.add(resolved);
+          skillPaths.push(f);
+        }
+      }
+    }
+  }
+}
+var MAX_SKILL_SIZE, PROJECT_MCP_CONFIGS, PROJECT_SKILL_FILES, PROJECT_SKILL_DIRS, SKILL_DIRS, SKILL_FILES;
+var init_machine_discovery = __esm({
+  "src/machine-discovery.ts"() {
+    MAX_SKILL_SIZE = 10 * 1024 * 1024;
+    PROJECT_MCP_CONFIGS = [
+      [".mcp.json", "mcpServers", null],
+      [".cursor/mcp.json", "mcpServers", null],
+      [".vscode/mcp.json", "servers", "jsonc"],
+      ["mcp_config.json", "servers", null],
+      ["mcp.json", "mcpServers", null],
+      [".kiro/settings/mcp.json", "mcpServers", null],
+      [".kilocode/mcp.json", "mcpServers", null],
+      [".roo/mcp.json", "mcpServers", null],
+      [".trae/mcp.json", "mcpServers", null],
+      [".amazonq/mcp.json", "mcpServers", null],
+      [".copilot/mcp-config.json", "mcpServers", null],
+      [".junie/mcp/mcp.json", "mcpServers", null],
+      [".grok/settings.json", "mcpServers", null]
+    ];
+    PROJECT_SKILL_FILES = [
+      ".cursorrules",
+      ".windsurfrules",
+      "CLAUDE.md",
+      ".claude/CLAUDE.md",
+      "AGENTS.md",
+      ".github/copilot-instructions.md",
+      "GEMINI.md",
+      ".junie/guidelines.md",
+      ".roomodes"
+    ];
+    PROJECT_SKILL_DIRS = [
+      ".cursor/rules",
+      ".roo/rules",
+      ".kiro/rules",
+      ".trae/rules",
+      ".junie/rules",
+      ".qwen/skills",
+      ".windsurf/rules"
+    ];
+    SKILL_DIRS = [
+      ".openclaw/skills",
+      ".openclaw/workspace/skills",
+      ".cursor/rules",
+      ".roo/rules",
+      ".continue/rules",
+      ".trae/rules",
+      ".kiro/rules",
+      ".qwen/skills"
+    ];
+    SKILL_FILES = [
+      ".cursorrules",
+      ".claude/CLAUDE.md",
+      ".github/copilot-instructions.md",
+      ".windsurfrules",
+      "AGENTS.md",
+      "CLAUDE.md",
+      "GEMINI.md"
+    ];
+  }
+});
+
+export {
+  PROJECT_MCP_CONFIGS,
+  PROJECT_SKILL_FILES,
+  PROJECT_SKILL_DIRS,
+  getWellKnownConfigs,
+  stripJsonComments,
+  scanMachine,
+  scanDirectory,
+  machine_discovery_exports,
+  init_machine_discovery
+};

package/dist/chunk-ZLRN7Q7C.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+export {
+  __esm,
+  __export,
+  __toCommonJS
+};