agentseal 0.9.0 → 0.9.1

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
+};

package/dist/chunk-ZNNQ2HKJ.js

@@ -0,0 +1,267 @@
+#!/usr/bin/env node
+import {
+  PROJECT_MCP_CONFIGS,
+  PROJECT_SKILL_DIRS,
+  PROJECT_SKILL_FILES,
+  init_machine_discovery,
+  stripJsonComments
+} from "./chunk-IO5DO7DS.js";
+import {
+  createMCPServerConfig
+} from "./chunk-4EOVMNW5.js";
+
+// src/guard/collectors/project.ts
+import { readdirSync as readdirSync2 } from "fs";
+import { join as join2, resolve as resolve2 } from "path";
+
+// src/guard/collectors/base.ts
+import { readFileSync, readdirSync, statSync } from "fs";
+import { homedir } from "os";
+import { join, resolve } from "path";
+init_machine_discovery();
+var AgentCollector = class {
+};
+var COLLECTORS = [];
+function registerCollector(collector) {
+  COLLECTORS.push(collector);
+}
+function getCollectors() {
+  return COLLECTORS;
+}
+function collectAll() {
+  return COLLECTORS.flatMap((c) => {
+    try {
+      return c.collect();
+    } catch {
+      return [];
+    }
+  });
+}
+var MAX_SKILL_SIZE = 10 * 1024 * 1024;
+function isFile(p) {
+  try {
+    return statSync(p).isFile();
+  } catch {
+    return false;
+  }
+}
+function isDir(p) {
+  try {
+    return statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function home(...parts) {
+  return join(homedir(), ...parts);
+}
+function appdata(...parts) {
+  if (process.platform !== "win32") return null;
+  const ad = process.env.APPDATA;
+  return ad ? join(ad, ...parts) : null;
+}
+function platformPath(paths) {
+  const sys = process.platform === "darwin" ? "Darwin" : process.platform === "win32" ? "Windows" : "Linux";
+  return paths[sys] ?? paths["all"] ?? null;
+}
+function parseMcpConfig(content) {
+  try {
+    return JSON.parse(content);
+  } catch {
+  }
+  try {
+    return JSON.parse(stripJsonComments(content));
+  } catch {
+    return {};
+  }
+}
+function readConfig(path, format) {
+  try {
+    let raw = readFileSync(path, "utf-8");
+    if (format === "jsonc") {
+      raw = stripJsonComments(raw);
+    }
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function extractMcpServers(config, sourceFile, agentType, mcpKey = "mcpServers") {
+  let servers;
+  if (mcpKey.includes(".")) {
+    const parts = mcpKey.split(".");
+    let node = config;
+    for (const part of parts) {
+      node = node && typeof node === "object" && !Array.isArray(node) ? node[part] : void 0;
+    }
+    servers = node ?? {};
+  } else {
+    servers = config[mcpKey] ?? {};
+  }
+  const results = [];
+  if (typeof servers !== "object" || servers === null || Array.isArray(servers)) {
+    return results;
+  }
+  for (const [srvName, srvCfg] of Object.entries(servers)) {
+    if (typeof srvCfg !== "object" || srvCfg === null) continue;
+    const cfg = srvCfg;
+    const command = String(cfg.command ?? cfg.cmd ?? "");
+    const rawArgs = cfg.args ?? cfg.arguments ?? [];
+    const args = Array.isArray(rawArgs) ? rawArgs.map(String) : [];
+    const rawEnv = cfg.env ?? cfg.envs ?? {};
+    const env = {};
+    if (typeof rawEnv === "object" && rawEnv !== null) {
+      for (const [k, v] of Object.entries(rawEnv)) {
+        env[k] = String(v);
+      }
+    }
+    const url = cfg.url ? String(cfg.url) : null;
+    const transport = url ? "sse" : "stdio";
+    results.push(
+      createMCPServerConfig({
+        name: srvName,
+        command,
+        args,
+        env,
+        sourceFile,
+        transport,
+        url,
+        agents: [agentType]
+      })
+    );
+  }
+  return results;
+}
+function collectSkillFiles(paths) {
+  const skills = [];
+  for (const p of paths) {
+    if (isFile(p)) {
+      try {
+        if (statSync(p).size > MAX_SKILL_SIZE) continue;
+      } catch {
+        continue;
+      }
+      skills.push({ path: resolve(p), platform: "global", format: "markdown" });
+    }
+  }
+  return skills;
+}
+function collectSkillDirs(dirs) {
+  const skills = [];
+  for (const dir of dirs) {
+    if (!isDir(dir)) continue;
+    try {
+      for (const entry of readdirSync(dir)) {
+        if (!entry.endsWith(".md")) continue;
+        const full = join(dir, entry);
+        if (!isFile(full)) continue;
+        try {
+          if (statSync(full).size > MAX_SKILL_SIZE) continue;
+        } catch {
+          continue;
+        }
+        skills.push({ path: resolve(full), platform: "global", format: "markdown" });
+      }
+    } catch {
+    }
+  }
+  return skills;
+}
+function makeAgent(name, agentType, configPath, mcpServers, skills, status) {
+  return { name, agentType, configPath, mcpServers, skills, status };
+}
+
+// src/guard/collectors/project.ts
+init_machine_discovery();
+var _projectDir = null;
+function setProjectDir(dir) {
+  _projectDir = dir;
+}
+function globPrefix(dir, prefix) {
+  try {
+    return readdirSync2(dir).filter((f) => f.startsWith(prefix)).map((f) => join2(dir, f)).filter(isFile);
+  } catch {
+    return [];
+  }
+}
+var ProjectCollector = class extends AgentCollector {
+  name = "Project";
+  collect() {
+    let dir = _projectDir;
+    if (!dir) {
+      try {
+        dir = process.cwd();
+      } catch {
+        return [];
+      }
+    }
+    if (!isDir(dir)) return [];
+    const servers = [];
+    const skills = [];
+    const seenSkills = /* @__PURE__ */ new Set();
+    for (const [relPath, mcpKey, fmt] of PROJECT_MCP_CONFIGS) {
+      const mcpFile = join2(dir, relPath);
+      if (!isFile(mcpFile)) continue;
+      const data = readConfig(mcpFile, fmt);
+      if (!data) continue;
+      const extracted = extractMcpServers(data, mcpFile, "project", mcpKey);
+      servers.push(...extracted);
+    }
+    for (const rel of PROJECT_SKILL_FILES) {
+      const candidate = join2(dir, rel);
+      if (isFile(candidate)) {
+        const resolved = resolve2(candidate);
+        if (!seenSkills.has(resolved)) {
+          seenSkills.add(resolved);
+          skills.push({ path: resolved, platform: "project", format: "markdown" });
+        }
+      }
+    }
+    for (const f of globPrefix(dir, ".clinerules-")) {
+      const resolved = resolve2(f);
+      if (!seenSkills.has(resolved)) {
+        seenSkills.add(resolved);
+        skills.push({ path: resolved, platform: "project", format: "markdown" });
+      }
+    }
+    for (const rel of PROJECT_SKILL_DIRS) {
+      const skillDir = join2(dir, rel);
+      if (!isDir(skillDir)) continue;
+      try {
+        for (const entry of readdirSync2(skillDir)) {
+          if (!entry.endsWith(".md")) continue;
+          const full = join2(skillDir, entry);
+          if (!isFile(full)) continue;
+          const resolved = resolve2(full);
+          if (!seenSkills.has(resolved)) {
+            seenSkills.add(resolved);
+            skills.push({ path: resolved, platform: "project", format: "markdown" });
+          }
+        }
+      } catch {
+      }
+    }
+    if (servers.length === 0 && skills.length === 0) return [];
+    return [makeAgent("Project", "project", dir, servers, skills, "found")];
+  }
+};
+registerCollector(new ProjectCollector());
+
+export {
+  AgentCollector,
+  registerCollector,
+  getCollectors,
+  collectAll,
+  isFile,
+  isDir,
+  home,
+  appdata,
+  platformPath,
+  parseMcpConfig,
+  readConfig,
+  extractMcpServers,
+  collectSkillFiles,
+  collectSkillDirs,
+  makeAgent,
+  setProjectDir
+};

package/dist/collectors-Y5Z2R2UT.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+import "./chunk-EGCYEYIX.js";
+import {
+  AgentCollector,
+  appdata,
+  collectAll,
+  collectSkillDirs,
+  collectSkillFiles,
+  extractMcpServers,
+  getCollectors,
+  home,
+  isDir,
+  isFile,
+  makeAgent,
+  parseMcpConfig,
+  platformPath,
+  readConfig,
+  registerCollector
+} from "./chunk-ZNNQ2HKJ.js";
+import "./chunk-IO5DO7DS.js";
+import "./chunk-4EOVMNW5.js";
+import "./chunk-ZLRN7Q7C.js";
+export {
+  AgentCollector,
+  appdata,
+  collectAll,
+  collectSkillDirs,
+  collectSkillFiles,
+  extractMcpServers,
+  getCollectors,
+  home,
+  isDir,
+  isFile,
+  makeAgent,
+  parseMcpConfig,
+  platformPath,
+  readConfig,
+  registerCollector
+};

package/dist/deep-reasoning-GHCZ3SO6.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+import {
+  DeepReasoningAnalyzer,
+  buildPrompt,
+  parseLlmResponse,
+  sanitizeName,
+  sanitizeText
+} from "./chunk-BXOPZ7UC.js";
+import "./chunk-4EOVMNW5.js";
+import "./chunk-ZLRN7Q7C.js";
+export {
+  DeepReasoningAnalyzer,
+  buildPrompt,
+  parseLlmResponse,
+  sanitizeName,
+  sanitizeText
+};

package/dist/fix-NOFNO7VW.js

@@ -0,0 +1,204 @@
+#!/usr/bin/env node
+import "./chunk-ZLRN7Q7C.js";
+
+// src/fix.ts
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  renameSync,
+  writeFileSync
+} from "fs";
+import { homedir } from "os";
+import { basename, dirname, extname, join, resolve } from "path";
+var QUARANTINE_DIR = join(homedir(), ".agentseal", "quarantine");
+var REPORTS_DIR = join(homedir(), ".agentseal", "reports");
+var BACKUPS_DIR = join(homedir(), ".agentseal", "backups");
+function manifestPath(quarantineDir) {
+  return join(quarantineDir, "manifest.json");
+}
+function rglob(dir) {
+  const results = [];
+  const walk = (d) => {
+    try {
+      for (const entry of readdirSync(d, { withFileTypes: true })) {
+        const full = join(d, entry.name);
+        if (entry.isDirectory()) walk(full);
+        else if (entry.isFile()) results.push(full);
+      }
+    } catch {
+    }
+  };
+  walk(dir);
+  return results;
+}
+function loadManifest(quarantineDir) {
+  const mp = manifestPath(quarantineDir);
+  if (!existsSync(mp)) return [];
+  try {
+    const data = JSON.parse(readFileSync(mp, "utf-8"));
+    if (Array.isArray(data)) return data;
+  } catch {
+  }
+  const entries = [];
+  for (const f of rglob(quarantineDir)) {
+    if (basename(f) === "manifest.json") continue;
+    const stem = basename(f, extname(f));
+    entries.push({
+      original_path: "",
+      quarantine_path: f,
+      reason: "recovered from corrupted manifest",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      skill_name: stem
+    });
+  }
+  return entries;
+}
+function saveManifest(quarantineDir, entries) {
+  mkdirSync(quarantineDir, { recursive: true });
+  writeFileSync(manifestPath(quarantineDir), JSON.stringify(entries, null, 2), "utf-8");
+}
+function quarantineSkill(skillPath, reason = "", quarantineDir) {
+  const qdir = quarantineDir ?? QUARANTINE_DIR;
+  const resolvedSkill = resolve(skillPath);
+  if (!existsSync(resolvedSkill)) {
+    throw new Error(`Skill not found: ${resolvedSkill}`);
+  }
+  const parts = resolvedSkill.split("/").filter(Boolean);
+  const relative = parts.length >= 2 ? join(parts[parts.length - 2], parts[parts.length - 1]) : basename(resolvedSkill);
+  let dest = join(qdir, relative);
+  if (existsSync(dest)) {
+    const stem = basename(dest, extname(dest));
+    const suffix = extname(dest);
+    const parent = dirname(dest);
+    let counter = 1;
+    while (existsSync(dest)) {
+      dest = join(parent, `${stem}_${counter}${suffix}`);
+      counter++;
+    }
+  }
+  mkdirSync(dirname(dest), { recursive: true });
+  renameSync(resolvedSkill, dest);
+  const entry = {
+    original_path: resolvedSkill,
+    quarantine_path: dest,
+    reason,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    skill_name: basename(resolvedSkill, extname(resolvedSkill))
+  };
+  const manifest = loadManifest(qdir);
+  manifest.push(entry);
+  saveManifest(qdir, manifest);
+  return entry;
+}
+function restoreSkill(skillName, quarantineDir) {
+  const qdir = quarantineDir ?? QUARANTINE_DIR;
+  const manifest = loadManifest(qdir);
+  let idx = -1;
+  for (let i = 0; i < manifest.length; i++) {
+    if (manifest[i].skill_name === skillName) {
+      idx = i;
+      break;
+    }
+  }
+  if (idx === -1) {
+    throw new Error(`Skill '${skillName}' not found in quarantine`);
+  }
+  const entry = manifest[idx];
+  if (!entry.original_path) {
+    throw new Error(
+      `Cannot restore '${skillName}': original path is empty (recovered from corrupted manifest). Re-quarantine or move manually.`
+    );
+  }
+  const original = resolve(entry.original_path);
+  const quarantined = resolve(entry.quarantine_path);
+  const qdirResolved = resolve(qdir);
+  if (!quarantined.startsWith(qdirResolved)) {
+    throw new Error(
+      `Cannot restore '${skillName}': quarantine path ${quarantined} is outside quarantine directory. Manifest may be tampered.`
+    );
+  }
+  if (existsSync(original)) {
+    throw new Error(`Cannot restore: original path already occupied: ${original}`);
+  }
+  if (!existsSync(quarantined)) {
+    throw new Error(`Quarantined file missing: ${quarantined}`);
+  }
+  mkdirSync(dirname(original), { recursive: true });
+  renameSync(quarantined, original);
+  manifest.splice(idx, 1);
+  saveManifest(qdir, manifest);
+  return original;
+}
+function listQuarantine(quarantineDir) {
+  const qdir = quarantineDir ?? QUARANTINE_DIR;
+  const manifest = loadManifest(qdir);
+  const required = ["original_path", "quarantine_path", "reason", "timestamp", "skill_name"];
+  return manifest.filter((e) => required.every((k) => k in e)).map((e) => ({
+    original_path: e.original_path,
+    quarantine_path: e.quarantine_path,
+    reason: e.reason,
+    timestamp: e.timestamp,
+    skill_name: e.skill_name
+  }));
+}
+function loadGuardReport(path, reportsDir) {
+  const target = path ?? join(reportsDir ?? REPORTS_DIR, "guard-latest.json");
+  if (!existsSync(target)) {
+    throw new Error(
+      `Guard report not found: ${target}
+Run 'agentseal guard' first to generate a report.`
+    );
+  }
+  return JSON.parse(readFileSync(target, "utf-8"));
+}
+function loadScanReport(path, reportsDir) {
+  const target = path ?? join(reportsDir ?? REPORTS_DIR, "scan-latest.json");
+  if (!existsSync(target)) {
+    throw new Error(
+      `Scan report not found: ${target}
+Run 'agentseal scan' first to generate a report.`
+    );
+  }
+  return JSON.parse(readFileSync(target, "utf-8"));
+}
+function saveReport(reportDict, reportType, reportsDir) {
+  if (reportType.includes("/") || reportType.includes("..") || reportType.includes("\\")) {
+    throw new Error("Invalid report type");
+  }
+  const dir = reportsDir ?? REPORTS_DIR;
+  mkdirSync(dir, { recursive: true });
+  const target = join(dir, `${reportType}-latest.json`);
+  writeFileSync(target, JSON.stringify(reportDict, null, 2), "utf-8");
+  return target;
+}
+function getFixableSkills(guardReport) {
+  const results = [];
+  for (const skill of guardReport.skill_results ?? []) {
+    if (skill.verdict === "danger") {
+      results.push({
+        name: skill.name ?? "",
+        path: skill.path ?? "",
+        findings: skill.findings ?? [],
+        verdict: skill.verdict ?? ""
+      });
+    }
+  }
+  return results;
+}
+export {
+  BACKUPS_DIR,
+  QUARANTINE_DIR,
+  REPORTS_DIR,
+  getFixableSkills,
+  listQuarantine,
+  loadGuardReport,
+  loadManifest,
+  loadScanReport,
+  manifestPath,
+  quarantineSkill,
+  restoreSkill,
+  saveManifest,
+  saveReport
+};

package/dist/http-AIVCASYV.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+import {
+  fromEndpoint
+} from "./chunk-XQGUICLL.js";
+import "./chunk-ZLRN7Q7C.js";
+export {
+  fromEndpoint
+};