mcptrustchecker 1.0.0

package/dist/acquire/manifest.js

@@ -0,0 +1,94 @@
+/*! MCP Trust Checker · https://mcptrustchecker.com · support@mcptrustchecker.com · © 2026 Illia Haidar · MIT */
+/**
+ * Offline acquisition: build a normalized ServerSurface from a pre-generated
+ * JSON manifest. Accepts several shapes so `mcptrustchecker scan tools.json` "just
+ * works": a raw `tools/list` result, a full surface object, or a hand-written
+ * `{ server, tools, prompts, resources }`.
+ */
+/** Coerce an untrusted transport object into typed, string-only fields. */
+function normalizeTransport(raw) {
+    if (!raw || typeof raw !== 'object')
+        return undefined;
+    const t = raw;
+    const kind = t.kind;
+    const validKind = kind === 'stdio' || kind === 'http' || kind === 'sse' ? kind : 'unknown';
+    return {
+        kind: validKind,
+        url: typeof t.url === 'string' ? t.url : undefined,
+        command: typeof t.command === 'string' ? t.command : undefined,
+        args: Array.isArray(t.args) ? t.args.filter((x) => typeof x === 'string') : undefined,
+        userControlledCommand: typeof t.userControlledCommand === 'boolean' ? t.userControlledCommand : undefined,
+    };
+}
+function asArray(v) {
+    return Array.isArray(v) ? v.filter((x) => x && typeof x === 'object') : [];
+}
+function str(v) {
+    return typeof v === 'string' ? v : undefined;
+}
+function normalizeTool(o) {
+    const name = str(o.name);
+    if (!name)
+        return null;
+    return {
+        name,
+        title: str(o.title),
+        description: str(o.description),
+        inputSchema: (o.inputSchema ?? o.input_schema),
+        outputSchema: (o.outputSchema ?? o.output_schema),
+        annotations: o.annotations,
+    };
+}
+function normalizePrompt(o) {
+    const name = str(o.name);
+    if (!name)
+        return null;
+    return {
+        name,
+        title: str(o.title),
+        description: str(o.description),
+        arguments: asArray(o.arguments).map((a) => ({
+            name: str(a.name) ?? '',
+            description: str(a.description),
+            required: Boolean(a.required),
+        })),
+    };
+}
+function normalizeResource(o) {
+    return {
+        uri: str(o.uri),
+        uriTemplate: str(o.uriTemplate),
+        name: str(o.name),
+        title: str(o.title),
+        description: str(o.description),
+        mimeType: str(o.mimeType),
+    };
+}
+/** Build a surface from an arbitrary manifest object. */
+export function surfaceFromManifest(input, origin, id) {
+    const root = (input && typeof input === 'object' ? input : {});
+    const serverObj = (root.server ?? {});
+    const meta = (root.serverInfo ?? root.server_info ?? {});
+    const tools = asArray(root.tools).map(normalizeTool).filter((t) => t !== null);
+    const prompts = asArray(root.prompts).map(normalizePrompt).filter((p) => p !== null);
+    const resources = asArray(root.resources).map(normalizeResource);
+    return {
+        id: id ?? str(root.id) ?? origin,
+        source: { kind: 'manifest', origin },
+        server: {
+            name: str(serverObj.name) ?? str(meta.name) ?? str(root.name),
+            version: str(serverObj.version) ?? str(meta.version),
+            title: str(serverObj.title),
+            instructions: str(serverObj.instructions) ?? str(root.instructions),
+            protocolVersion: str(root.protocolVersion),
+            capabilities: serverObj.capabilities ??
+                root.capabilities ??
+                undefined,
+        },
+        tools,
+        prompts,
+        resources,
+        transport: normalizeTransport(root.transport),
+        packageMeta: root.packageMeta,
+    };
+}

package/dist/acquire/npm.d.ts

@@ -0,0 +1,10 @@
+/*! MCP Trust Checker · https://mcptrustchecker.com · support@mcptrustchecker.com · © 2026 Illia Haidar · MIT */
+/**
+ * Best-effort package-metadata resolution for the supply-chain stage. Network
+ * access is opt-in (`--online`); everything degrades gracefully offline.
+ */
+import type { PackageMeta } from '../types.js';
+/** Fetch npm registry metadata for a package (latest dist-tag). */
+export declare function fetchNpmMeta(name: string): Promise<PackageMeta>;
+/** Fetch PyPI metadata for a package. */
+export declare function fetchPypiMeta(name: string): Promise<PackageMeta>;

package/dist/acquire/npm.js

@@ -0,0 +1,55 @@
+/*! MCP Trust Checker · https://mcptrustchecker.com · support@mcptrustchecker.com · © 2026 Illia Haidar · MIT */
+/**
+ * Best-effort package-metadata resolution for the supply-chain stage. Network
+ * access is opt-in (`--online`); everything degrades gracefully offline.
+ */
+async function getJson(url, timeoutMs = 8000) {
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), timeoutMs);
+    try {
+        const res = await fetch(url, { signal: ctrl.signal, headers: { 'User-Agent': 'mcptrustchecker' } });
+        if (!res.ok)
+            return null;
+        return await res.json();
+    }
+    catch {
+        return null;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/** Fetch npm registry metadata for a package (latest dist-tag). */
+export async function fetchNpmMeta(name) {
+    const meta = { registry: 'npm', name };
+    const packument = (await getJson(`https://registry.npmjs.org/${encodeURIComponent(name).replace('%40', '@')}`));
+    if (packument && typeof packument === 'object') {
+        const latest = packument['dist-tags']?.latest;
+        const version = latest ?? Object.keys(packument.versions ?? {}).pop();
+        meta.version = version;
+        const v = version ? packument.versions?.[version] : undefined;
+        if (v) {
+            meta.scripts = v.scripts ?? {};
+            meta.dependencies = Object.keys(v.dependencies ?? {});
+            meta.license = typeof v.license === 'string' ? v.license : v.license == null ? null : String(v.license);
+            const repo = v.repository;
+            meta.repositoryUrl = typeof repo === 'string' ? repo : repo?.url ?? null;
+        }
+        meta.publishedAt = version ? packument.time?.[version] ?? null : null;
+    }
+    const encoded = encodeURIComponent(name).replace('%40', '@');
+    const downloads = (await getJson(`https://api.npmjs.org/downloads/point/last-week/${encoded}`));
+    meta.weeklyDownloads = downloads?.downloads ?? null;
+    return meta;
+}
+/** Fetch PyPI metadata for a package. */
+export async function fetchPypiMeta(name) {
+    const meta = { registry: 'pypi', name };
+    const data = (await getJson(`https://pypi.org/pypi/${encodeURIComponent(name)}/json`));
+    if (data?.info) {
+        meta.version = data.info.version;
+        meta.license = data.info.license || null;
+        meta.repositoryUrl = data.info.project_urls?.Source ?? data.info.home_page ?? null;
+    }
+    return meta;
+}

package/dist/acquire/source.d.ts

@@ -0,0 +1,16 @@
+/*! MCP Trust Checker · https://mcptrustchecker.com · support@mcptrustchecker.com · © 2026 Illia Haidar · MIT */
+/**
+ * Acquire a server's implementation source from a local package directory, so
+ * the scan can analyze what the code *does* — not only what its tools *claim*.
+ * Bounded (file count, per-file and total size) so a huge repo can't OOM the
+ * scan, and never executes any of the code it reads. Offline.
+ */
+import type { ServerSurface, SourceFile } from '../types.js';
+/** Recursively collect scannable source files from a directory (bounded). */
+export declare function readSourceFiles(dir: string): SourceFile[];
+/**
+ * Build a scan surface from a local package directory: its implementation source
+ * (for MTC-SRC-* analysis), its package metadata (for supply-chain checks), and
+ * a tools manifest if the directory ships one (tools.json / mcp-tools.json).
+ */
+export declare function surfaceFromPackageDir(dir: string): ServerSurface;

package/dist/acquire/source.js

@@ -0,0 +1,109 @@
+/*! MCP Trust Checker · https://mcptrustchecker.com · support@mcptrustchecker.com · © 2026 Illia Haidar · MIT */
+/**
+ * Acquire a server's implementation source from a local package directory, so
+ * the scan can analyze what the code *does* — not only what its tools *claim*.
+ * Bounded (file count, per-file and total size) so a huge repo can't OOM the
+ * scan, and never executes any of the code it reads. Offline.
+ */
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import { join, relative, extname } from 'node:path';
+import { SOURCE_EXTENSIONS } from '../data/sourcePatterns.js';
+import { surfaceFromManifest } from './manifest.js';
+const SKIP_DIRS = new Set(['node_modules', '.git', 'dist', 'build', 'coverage', '.next', '__pycache__', 'venv', '.venv', 'vendor']);
+const MAX_FILES = 400;
+const MAX_FILE_BYTES = 512 * 1024; // 512 KB per file
+const MAX_TOTAL_BYTES = 12 * 1024 * 1024; // 12 MB total
+/** Recursively collect scannable source files from a directory (bounded). */
+export function readSourceFiles(dir) {
+    const out = [];
+    let total = 0;
+    const walk = (d) => {
+        if (out.length >= MAX_FILES || total >= MAX_TOTAL_BYTES)
+            return;
+        let entries;
+        try {
+            entries = readdirSync(d);
+        }
+        catch {
+            return;
+        }
+        for (const name of entries) {
+            if (out.length >= MAX_FILES || total >= MAX_TOTAL_BYTES)
+                return;
+            const full = join(d, name);
+            let st;
+            try {
+                st = statSync(full);
+            }
+            catch {
+                continue;
+            }
+            if (st.isDirectory()) {
+                if (!SKIP_DIRS.has(name) && !name.startsWith('.'))
+                    walk(full);
+                continue;
+            }
+            if (!SOURCE_EXTENSIONS.has(extname(name).toLowerCase()))
+                continue;
+            if (st.size > MAX_FILE_BYTES)
+                continue;
+            try {
+                out.push({ path: relative(dir, full) || name, content: readFileSync(full, 'utf8') });
+                total += st.size;
+            }
+            catch {
+                /* unreadable file — skip */
+            }
+        }
+    };
+    walk(dir);
+    return out;
+}
+/** Read a package.json (if present) into the surface's package metadata. */
+function readPackageMeta(dir) {
+    const pkgPath = join(dir, 'package.json');
+    if (!existsSync(pkgPath))
+        return undefined;
+    try {
+        const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+        return {
+            registry: 'npm',
+            name: typeof pkg.name === 'string' ? pkg.name : undefined,
+            version: typeof pkg.version === 'string' ? pkg.version : undefined,
+            scripts: pkg.scripts ?? undefined,
+            dependencies: pkg.dependencies ? Object.keys(pkg.dependencies) : undefined,
+            license: typeof pkg.license === 'string' ? pkg.license : null,
+            repositoryUrl: typeof pkg.repository === 'string'
+                ? pkg.repository
+                : (pkg.repository?.url ?? null),
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Build a scan surface from a local package directory: its implementation source
+ * (for MTC-SRC-* analysis), its package metadata (for supply-chain checks), and
+ * a tools manifest if the directory ships one (tools.json / mcp-tools.json).
+ */
+export function surfaceFromPackageDir(dir) {
+    let manifest = {};
+    for (const name of ['tools.json', 'mcp-tools.json', 'mcp.json']) {
+        const p = join(dir, name);
+        if (existsSync(p)) {
+            try {
+                manifest = JSON.parse(readFileSync(p, 'utf8'));
+            }
+            catch {
+                /* ignore an unparseable sidecar manifest */
+            }
+            break;
+        }
+    }
+    const surface = surfaceFromManifest(manifest, dir, dir);
+    surface.source = { kind: 'package', origin: dir };
+    surface.packageMeta = { ...readPackageMeta(dir), ...(surface.packageMeta ?? {}) };
+    surface.sourceFiles = readSourceFiles(dir);
+    return surface;
+}

package/dist/cli/index.d.ts

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+/*! MCP Trust Checker · https://mcptrustchecker.com · support@mcptrustchecker.com · © 2026 Illia Haidar · MIT */
+/**
+ * MCP Trust Checker command-line interface.
+ *
+ *   mcptrustchecker scan <target>       scan a manifest / URL / package / client config
+ *   mcptrustchecker pin <target>        scan and (re)pin the integrity lockfile
+ *   mcptrustchecker diff <target>       fail if the surface drifted since the pin
+ *   mcptrustchecker rules               list every rule
+ *   mcptrustchecker explain <ruleId>    describe a rule
+ *   mcptrustchecker version | help
+ *
+ * Uses only Node built-ins (node:util parseArgs) — no arg-parsing dependency.
+ */
+export {};