@akshay7273/skill-advisories 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Akshay Kumar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,45 @@
+# skill-advisories
+
+Open advisory database for AI agent skills, plugins, and MCP servers — OSV-style, machine-readable threat data for the agent ecosystem.
+
+Every advisory documents a malicious, vulnerable, or typosquatted agent skill, backed by at least one published public reference (vendor report, researcher writeup, or registry takedown).
+
+## The feed (public API)
+
+Consume the database directly — no install needed:
+
+- Full feed: `https://raw.githubusercontent.com/Akshay7273/skill-advisories/main/feed/feed.json`
+- Fast lookup index (`ecosystem:name` → advisory ids): `https://raw.githubusercontent.com/Akshay7273/skill-advisories/main/feed/index.json`
+- Advisory schema: [`schema/advisory.schema.json`](schema/advisory.schema.json)
+
+## CLI
+
+```
+
+# Check specific skill names
+
+npx @akshay7273/skill-advisories check omnicogg my-other-skill
+
+# Scan installed skill directories (~/.claude/skills, ~/.openclaw/skills, ...)
+
+npx @akshay7273/skill-advisories scan
+
+# Scan a specific directory, machine-readable output
+
+npx @akshay7273/skill-advisories scan ./skills --json
+
+```
+
+Options: `--json` (machine-readable output), `--feed <url-or-path>` (alternate feed source).
+
+Exit codes: `0` no advisories matched · `1` matches found (CI-friendly) · `2` usage or feed error.
+
+## Data integrity
+
+1. Every advisory cites at least one published public reference.
+2. No hearsay: submissions without a published report or reproducible evidence are not listed.
+3. Advisories can be withdrawn; disputes are handled via GitHub issues.
+
+## License
+
+Code: MIT. Advisory data: CC-BY-4.0 — free to use with attribution.

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,123 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+import pc from "picocolors";
+import { DEFAULT_FEED_URL, loadFeed, matchNames } from "./lookup.js";
+import { defaultSkillDirs, listInstalledSkills } from "./scan.js";
+const VERSION = createRequire(import.meta.url)("../package.json").version;
+const HELP = `skill-advisories ${VERSION} — open advisory database for AI agent skills
+
+Usage:
+  skill-advisories check <name...>   Check skill names against the advisory feed
+  skill-advisories scan [dir...]     Scan installed skill directories (defaults to known locations)
+
+Options:
+  --json           Machine-readable JSON output
+  --feed <source>  Feed URL or local file path (default: official feed)
+  --help, -h       Show this help
+  --version, -v    Show version
+
+Exit codes: 0 = no advisories matched, 1 = matches found, 2 = usage or feed error`;
+function fail(message) {
+    console.error(pc.red(`error: ${message}`));
+    process.exit(2);
+}
+function parseArgs(argv) {
+    const positionals = [];
+    let json = false;
+    let feed = DEFAULT_FEED_URL;
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === "--json") {
+            json = true;
+        }
+        else if (arg === "--feed") {
+            i++;
+            const value = argv[i];
+            if (!value)
+                fail("--feed requires a value");
+            feed = value;
+        }
+        else if (arg === "--help" || arg === "-h") {
+            console.log(HELP);
+            process.exit(0);
+        }
+        else if (arg === "--version" || arg === "-v") {
+            console.log(VERSION);
+            process.exit(0);
+        }
+        else if (arg.startsWith("--")) {
+            fail(`unknown option "${arg}"`);
+        }
+        else {
+            positionals.push(arg);
+        }
+    }
+    const [command, ...rest] = positionals;
+    return { command, positionals: rest, json, feed };
+}
+async function loadFeedOrFail(source) {
+    try {
+        return await loadFeed(source);
+    }
+    catch (err) {
+        fail(err instanceof Error ? err.message : String(err));
+    }
+}
+function report(checked, matches, json) {
+    if (json) {
+        console.log(JSON.stringify({
+            checked,
+            matchCount: matches.length,
+            matches: matches.map((m) => ({
+                query: m.query,
+                id: m.advisory.id,
+                type: m.advisory.type,
+                severity: m.advisory.severity,
+                summary: m.advisory.summary,
+                references: m.advisory.references.map((r) => r.url),
+            })),
+        }, null, 2));
+    }
+    else if (matches.length === 0) {
+        console.log(pc.green(`\u2705 ${checked} skill(s) checked \u2014 no advisories matched`));
+    }
+    else {
+        console.log(pc.red(`\u274c ${matches.length} advisory match(es) across ${checked} skill(s) checked:`));
+        for (const m of matches) {
+            console.log(`  ${pc.bold(m.query)} \u2192 ${m.advisory.id} [${m.advisory.severity}] ${m.advisory.summary}`);
+            for (const ref of m.advisory.references) {
+                console.log(`      ${ref.url}`);
+            }
+        }
+    }
+    process.exitCode = matches.length > 0 ? 1 : 0;
+}
+const args = parseArgs(process.argv.slice(2));
+if (!args.command) {
+    console.log(HELP);
+    process.exit(2);
+}
+if (args.command === "check") {
+    if (args.positionals.length === 0)
+        fail("check requires at least one skill name");
+    const feed = await loadFeedOrFail(args.feed);
+    report(args.positionals.length, matchNames(feed, args.positionals), args.json);
+}
+else if (args.command === "scan") {
+    const dirs = args.positionals.length > 0 ? args.positionals : defaultSkillDirs();
+    const installed = await listInstalledSkills(dirs);
+    const names = installed.flatMap((d) => d.names);
+    if (!args.json) {
+        for (const d of installed) {
+            console.log(pc.dim(`scanning ${d.dir} (${d.names.length} skills)`));
+        }
+        if (installed.length === 0) {
+            console.log(pc.yellow("no skill directories found"));
+        }
+    }
+    const feed = await loadFeedOrFail(args.feed);
+    report(names.length, matchNames(feed, names), args.json);
+}
+else {
+    fail(`unknown command "${args.command}"`);
+}

package/dist/compile-cli.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/compile-cli.js

@@ -0,0 +1,18 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import pc from "picocolors";
+import { buildFeed } from "./compile.js";
+import { loadAdvisories } from "./load.js";
+import { validateAdvisories } from "./validate.js";
+const dir = process.argv[2] ?? "advisories";
+const loaded = await loadAdvisories(dir);
+const problems = await validateAdvisories(loaded);
+if (problems.length > 0) {
+    console.log(pc.red(`\u274c refusing to compile: ${problems.length} validation problem(s). Run: npm run validate`));
+    process.exit(1);
+}
+const { feed, index } = buildFeed(loaded.map((l) => l.advisory));
+await mkdir("feed", { recursive: true });
+await writeFile("feed/feed.json", JSON.stringify(feed, null, 2) + "\n", "utf8");
+await writeFile("feed/index.json", JSON.stringify(index, null, 2) + "\n", "utf8");
+console.log(pc.green(`\u2705 feed/feed.json written \u2014 ${feed.advisory_count} advisories (test entries excluded)`));
+console.log(pc.green(`\u2705 feed/index.json written \u2014 ${Object.keys(index).length} artifact keys`));

package/dist/compile.d.ts

@@ -0,0 +1,21 @@
+import type { Advisory } from "./types.js";
+export type Feed = {
+    schema_version: "1";
+    name: string;
+    source: string;
+    generated: string;
+    advisory_count: number;
+    advisories: Advisory[];
+};
+export type FeedIndex = Record<string, string[]>;
+export declare const FEED_NAME = "skill-advisories";
+export declare const FEED_SOURCE = "https://github.com/Akshay7273/skill-advisories";
+/**
+ * Build the distributable feed and lookup index from validated advisories.
+ * Test advisories never enter the feed. Withdrawn advisories stay in the
+ * feed (with their withdrawn timestamp) but are removed from the index.
+ */
+export declare function buildFeed(advisories: Advisory[], now?: Date): {
+    feed: Feed;
+    index: FeedIndex;
+};

package/dist/compile.js

@@ -0,0 +1,34 @@
+export const FEED_NAME = "skill-advisories";
+export const FEED_SOURCE = "https://github.com/Akshay7273/skill-advisories";
+/**
+ * Build the distributable feed and lookup index from validated advisories.
+ * Test advisories never enter the feed. Withdrawn advisories stay in the
+ * feed (with their withdrawn timestamp) but are removed from the index.
+ */
+export function buildFeed(advisories, now = new Date()) {
+    const live = advisories
+        .filter((a) => a.type !== "test")
+        .sort((a, b) => a.id.localeCompare(b.id));
+    const index = {};
+    for (const adv of live) {
+        if (adv.withdrawn)
+            continue;
+        for (const artifact of adv.artifacts) {
+            const key = `${artifact.ecosystem}:${artifact.name.toLowerCase()}`;
+            if (!index[key])
+                index[key] = [];
+            index[key].push(adv.id);
+        }
+    }
+    return {
+        feed: {
+            schema_version: "1",
+            name: FEED_NAME,
+            source: FEED_SOURCE,
+            generated: now.toISOString(),
+            advisory_count: live.length,
+            advisories: live,
+        },
+        index,
+    };
+}

package/dist/load.d.ts

@@ -0,0 +1,10 @@
+import type { Advisory } from "./types.js";
+export type LoadedAdvisory = {
+    file: string;
+    advisory: Advisory;
+};
+/**
+ * Load every .json advisory in a directory (sorted by filename).
+ * Throws on unparseable JSON.
+ */
+export declare function loadAdvisories(dir: string): Promise<LoadedAdvisory[]>;

package/dist/load.js

@@ -0,0 +1,22 @@
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+/**
+ * Load every .json advisory in a directory (sorted by filename).
+ * Throws on unparseable JSON.
+ */
+export async function loadAdvisories(dir) {
+    const files = (await readdir(dir)).filter((f) => f.endsWith(".json")).sort();
+    const loaded = [];
+    for (const file of files) {
+        const raw = await readFile(join(dir, file), "utf8");
+        let advisory;
+        try {
+            advisory = JSON.parse(raw);
+        }
+        catch {
+            throw new Error(`${file}: not valid JSON`);
+        }
+        loaded.push({ file, advisory });
+    }
+    return loaded;
+}

package/dist/lookup.d.ts

@@ -0,0 +1,15 @@
+import type { Feed } from "./compile.js";
+import type { Advisory } from "./types.js";
+export declare const DEFAULT_FEED_URL = "https://raw.githubusercontent.com/Akshay7273/skill-advisories/main/feed/feed.json";
+export type Match = {
+    query: string;
+    advisory: Advisory;
+    artifactNames: string[];
+};
+/** Load the advisory feed from a URL (http/https) or a local file path. */
+export declare function loadFeed(source?: string): Promise<Feed>;
+/**
+ * Find advisories whose artifacts match any of the given names
+ * (case-insensitive, across all ecosystems). Withdrawn advisories are skipped.
+ */
+export declare function matchNames(feed: Feed, names: string[]): Match[];

package/dist/lookup.js

@@ -0,0 +1,33 @@
+import { readFile } from "node:fs/promises";
+export const DEFAULT_FEED_URL = "https://raw.githubusercontent.com/Akshay7273/skill-advisories/main/feed/feed.json";
+/** Load the advisory feed from a URL (http/https) or a local file path. */
+export async function loadFeed(source = DEFAULT_FEED_URL) {
+    if (source.startsWith("http://") || source.startsWith("https://")) {
+        const res = await fetch(source);
+        if (!res.ok)
+            throw new Error(`failed to fetch feed: HTTP ${res.status}`);
+        return (await res.json());
+    }
+    return JSON.parse(await readFile(source, "utf8"));
+}
+/**
+ * Find advisories whose artifacts match any of the given names
+ * (case-insensitive, across all ecosystems). Withdrawn advisories are skipped.
+ */
+export function matchNames(feed, names) {
+    const matches = [];
+    for (const query of names) {
+        const q = query.toLowerCase();
+        for (const advisory of feed.advisories) {
+            if (advisory.withdrawn)
+                continue;
+            const hits = advisory.artifacts
+                .filter((a) => a.name.toLowerCase() === q)
+                .map((a) => a.name);
+            if (hits.length > 0) {
+                matches.push({ query, advisory, artifactNames: hits });
+            }
+        }
+    }
+    return matches;
+}

package/dist/scan.d.ts

@@ -0,0 +1,11 @@
+/** Known agent skill install locations, relative to the home directory. */
+export declare const KNOWN_SKILL_DIRS: string[];
+export declare function defaultSkillDirs(): string[];
+/**
+ * List installed skills (subdirectory names) in each existing directory.
+ * Missing or unreadable directories are silently skipped.
+ */
+export declare function listInstalledSkills(dirs: string[]): Promise<Array<{
+    dir: string;
+    names: string[];
+}>>;

package/dist/scan.js

@@ -0,0 +1,34 @@
+import { readdir } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+/** Known agent skill install locations, relative to the home directory. */
+export const KNOWN_SKILL_DIRS = [
+    ".claude/skills",
+    ".openclaw/skills",
+    ".clawdbot/skills",
+    ".moltbot/skills",
+];
+export function defaultSkillDirs() {
+    return KNOWN_SKILL_DIRS.map((d) => join(homedir(), d));
+}
+/**
+ * List installed skills (subdirectory names) in each existing directory.
+ * Missing or unreadable directories are silently skipped.
+ */
+export async function listInstalledSkills(dirs) {
+    const found = [];
+    for (const dir of dirs) {
+        try {
+            const entries = await readdir(dir, { withFileTypes: true });
+            const names = entries
+                .filter((e) => e.isDirectory())
+                .map((e) => e.name)
+                .sort();
+            found.push({ dir, names });
+        }
+        catch {
+            // directory doesn't exist or is unreadable; skip
+        }
+    }
+    return found;
+}

package/dist/types.d.ts

@@ -0,0 +1,30 @@
+export type AdvisoryType = "malicious" | "vulnerable" | "typosquat" | "compromised" | "test";
+export type Ecosystem = "claude-skill" | "claude-plugin" | "clawhub" | "mcp-server" | "npm" | "pypi" | "vscode-extension" | "github-action";
+export type Behavior = "credential-theft" | "data-exfiltration" | "backdoor" | "malware-dropper" | "prompt-injection" | "crypto-theft" | "spam" | "other";
+export type Severity = "critical" | "high" | "medium" | "low";
+export type Reference = {
+    type: "REPORT" | "ADVISORY" | "ARTICLE" | "WEB";
+    url: string;
+};
+export type Artifact = {
+    ecosystem: Ecosystem;
+    name: string;
+    publisher?: string;
+    versions?: string[];
+    sha256?: string[];
+};
+export type Advisory = {
+    schema_version: "1";
+    id: string;
+    type: AdvisoryType;
+    summary: string;
+    details?: string;
+    severity: Severity;
+    behaviors?: Behavior[];
+    artifacts: Artifact[];
+    references: Reference[];
+    credits?: string[];
+    published: string;
+    modified: string;
+    withdrawn?: string;
+};

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/validate-cli.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/validate-cli.js

@@ -0,0 +1,16 @@
+import pc from "picocolors";
+import { loadAdvisories } from "./load.js";
+import { validateAdvisories } from "./validate.js";
+const dir = process.argv[2] ?? "advisories";
+const loaded = await loadAdvisories(dir);
+const problems = await validateAdvisories(loaded);
+if (problems.length === 0) {
+    console.log(pc.green(`\u2705 ${loaded.length} advisor${loaded.length === 1 ? "y" : "ies"} valid in "${dir}"`));
+}
+else {
+    console.log(pc.red(`\u274c ${problems.length} problem(s) in "${dir}":`));
+    for (const p of problems) {
+        console.log(`  ${pc.bold(p.file)} \u2014 ${p.problem}`);
+    }
+    process.exitCode = 1;
+}

package/dist/validate.d.ts

@@ -0,0 +1,10 @@
+import type { LoadedAdvisory } from "./load.js";
+export type ValidationProblem = {
+    file: string;
+    problem: string;
+};
+/**
+ * Validate advisories against the JSON Schema, then enforce repo invariants:
+ * filename matches id, ids are unique, modified is not earlier than published.
+ */
+export declare function validateAdvisories(loaded: LoadedAdvisory[]): Promise<ValidationProblem[]>;

package/dist/validate.js

@@ -0,0 +1,40 @@
+import { readFile } from "node:fs/promises";
+import _Ajv2020 from "ajv/dist/2020.js";
+import _addFormats from "ajv-formats";
+// ajv and ajv-formats are CommonJS. Under module=NodeNext, TypeScript types
+// their default import as the module namespace, while Node/tsx resolve it to
+// the class/function at runtime. These casts bridge that gap - do not simplify.
+const Ajv2020 = _Ajv2020;
+const addFormats = _addFormats;
+const SCHEMA_URL = new URL("../schema/advisory.schema.json", import.meta.url);
+/**
+ * Validate advisories against the JSON Schema, then enforce repo invariants:
+ * filename matches id, ids are unique, modified is not earlier than published.
+ */
+export async function validateAdvisories(loaded) {
+    const schema = JSON.parse(await readFile(SCHEMA_URL, "utf8"));
+    const ajv = new Ajv2020({ allErrors: true });
+    addFormats(ajv);
+    const validate = ajv.compile(schema);
+    const problems = [];
+    const seen = new Set();
+    for (const { file, advisory } of loaded) {
+        if (!validate(advisory)) {
+            for (const err of validate.errors ?? []) {
+                problems.push({ file, problem: `schema: ${err.instancePath || "/"} ${err.message}` });
+            }
+            continue;
+        }
+        if (file !== `${advisory.id}.json`) {
+            problems.push({ file, problem: `filename must be ${advisory.id}.json` });
+        }
+        if (seen.has(advisory.id)) {
+            problems.push({ file, problem: `duplicate id ${advisory.id}` });
+        }
+        seen.add(advisory.id);
+        if (Date.parse(advisory.modified) < Date.parse(advisory.published)) {
+            problems.push({ file, problem: "modified is earlier than published" });
+        }
+    }
+    return problems;
+}