toolstile 0.0.0-stage → 0.1.1

package/dist/sources.js

@@ -0,0 +1,211 @@
+import { readFileSync, statSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { parseConfig } from "./parse.js";
+export const CLIENT_NAMES = {
+    "claude-code": "Claude Code",
+    "claude-desktop": "Claude Desktop",
+    cursor: "Cursor",
+    codex: "Codex",
+    vscode: "VS Code",
+    windsurf: "Windsurf",
+    gemini: "Gemini CLI",
+    cline: "Cline",
+};
+function appData({ home, platform, env }) {
+    if (platform === "darwin")
+        return join(home, "Library", "Application Support");
+    if (platform === "win32")
+        return env.APPDATA ?? join(home, "AppData", "Roaming");
+    return env.XDG_CONFIG_HOME ?? join(home, ".config");
+}
+function candidates(opts) {
+    const { home, cwd, env } = opts;
+    const data = appData(opts);
+    const codexHome = env.CODEX_HOME ?? join(home, ".codex");
+    const clineSettings = ["globalStorage", "saoudrizwan.claude-dev", "settings", "cline_mcp_settings.json"];
+    const list = [
+        { client: "claude-code", path: join(home, ".claude.json"), kind: "claude-json" },
+        { client: "claude-code", path: join(home, ".claude", "settings.json"), kind: "claude-settings" },
+        { client: "claude-desktop", path: join(data, "Claude", "claude_desktop_config.json"), kind: "mcp" },
+        { client: "cursor", path: join(home, ".cursor", "mcp.json"), kind: "mcp" },
+        { client: "codex", path: join(codexHome, "config.toml"), kind: "codex" },
+        { client: "windsurf", path: join(home, ".codeium", "windsurf", "mcp_config.json"), kind: "mcp" },
+        { client: "gemini", path: join(home, ".gemini", "settings.json"), kind: "mcp" },
+    ];
+    for (const edition of ["Code", "Code - Insiders"]) {
+        list.push({ client: "vscode", path: join(data, edition, "User", "settings.json"), kind: "vscode-settings" }, { client: "vscode", path: join(data, edition, "User", "mcp.json"), kind: "vscode-mcp" }, { client: "cline", path: join(data, edition, "User", ...clineSettings), kind: "mcp" });
+    }
+    list.push({ client: "cline", path: join(data, "Cursor", "User", ...clineSettings), kind: "mcp" });
+    if (cwd) {
+        const dir = resolve(cwd);
+        list.push({ client: "claude-code", path: join(dir, ".mcp.json"), kind: "mcp" }, { client: "claude-code", path: join(dir, ".claude", "settings.json"), kind: "claude-settings" }, { client: "claude-code", path: join(dir, ".claude", "settings.local.json"), kind: "claude-settings" }, { client: "cursor", path: join(dir, ".cursor", "mcp.json"), kind: "mcp" }, { client: "vscode", path: join(dir, ".vscode", "mcp.json"), kind: "vscode-mcp" }, { client: "gemini", path: join(dir, ".gemini", "settings.json"), kind: "mcp" }, { client: "codex", path: join(dir, ".codex", "config.toml"), kind: "codex" });
+    }
+    const seen = new Set();
+    return list.filter((c) => (seen.has(c.path) ? false : (seen.add(c.path), true)));
+}
+const isObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+const str = (v) => (typeof v === "string" ? v : undefined);
+const strings = (v) => Array.isArray(v) ? v.filter((x) => typeof x === "string") : [];
+function stringRecord(v) {
+    const out = {};
+    if (isObject(v))
+        for (const [k, x] of Object.entries(v))
+            if (typeof x === "string")
+                out[k] = x;
+    return out;
+}
+/** Appends a key to a pointer, quoting keys that are not plain identifiers. */
+export function pointerJoin(base, key) {
+    const part = /^[A-Za-z_$][\w$-]*$/.test(key) ? key : /^\d+$/.test(key) ? `[${key}]` : `[${JSON.stringify(key)}]`;
+    if (!base)
+        return part;
+    return part.startsWith("[") ? `${base}${part}` : `${base}.${part}`;
+}
+function toServer(client, file, pointer, name, v) {
+    if (!isObject(v))
+        return null;
+    const extraSecrets = {};
+    const bearer = str(v.bearer_token);
+    if (bearer)
+        extraSecrets.bearer_token = bearer;
+    return {
+        client,
+        file,
+        pointer,
+        name,
+        command: str(v.command),
+        args: strings(v.args),
+        env: stringRecord(v.env),
+        url: str(v.url) ?? str(v.serverUrl) ?? str(v.httpUrl),
+        headers: { ...stringRecord(v.headers), ...stringRecord(v.http_headers) },
+        extraSecrets,
+        autoApproved: [...strings(v.alwaysAllow), ...strings(v.autoApprove)],
+    };
+}
+function serversAt(client, file, base, v) {
+    if (!isObject(v))
+        return [];
+    const out = [];
+    for (const [name, def] of Object.entries(v)) {
+        const server = toServer(client, file, pointerJoin(base, name), name, def);
+        if (server)
+            out.push(server);
+    }
+    return out;
+}
+function claudeApprovals(file) {
+    const data = file.data;
+    if (!isObject(data))
+        return [];
+    const out = [];
+    if (data.enableAllProjectMcpServers === true) {
+        out.push({
+            client: file.client,
+            location: { file: file.path, pointer: "enableAllProjectMcpServers" },
+            subject: "every MCP server in project .mcp.json files",
+        });
+    }
+    const allow = isObject(data.permissions) ? strings(data.permissions.allow) : [];
+    allow.forEach((rule, i) => {
+        // `mcp__server` and `mcp__server__*` approve every tool of a server; named tools are deliberate.
+        if (!rule.startsWith("mcp__"))
+            return;
+        const rest = rule.slice("mcp__".length);
+        if (rest === "*" || !rest.includes("__") || rest.endsWith("__*")) {
+            out.push({
+                client: file.client,
+                location: { file: file.path, pointer: `permissions.allow[${i}]` },
+                subject: rule,
+            });
+        }
+    });
+    return out;
+}
+/**
+ * Who besides the owner can read a file, given its mode and the modes of every folder above it.
+ * A group or other user needs read on the file and execute (traverse) on each folder.
+ */
+export function exposureOf(fileMode, ancestorModes) {
+    if (fileMode & 0o004 && ancestorModes.every((m) => m & 0o001))
+        return "others";
+    if (fileMode & 0o040 && ancestorModes.every((m) => m & 0o010))
+        return "group";
+    return null;
+}
+function ancestorModes(path) {
+    const modes = [];
+    let dir = dirname(path);
+    for (;;) {
+        try {
+            modes.push(statSync(dir).mode & 0o777);
+        }
+        catch {
+            // An unreadable folder is not traversable by us either; treat it as closed.
+            modes.push(0);
+        }
+        const parent = dirname(dir);
+        if (parent === dir)
+            return modes;
+        dir = parent;
+    }
+}
+export function discover(opts) {
+    const result = { files: [], unreadable: [], servers: [], approvals: [] };
+    for (const c of candidates(opts)) {
+        let text;
+        let mode;
+        try {
+            const stat = statSync(c.path);
+            if (!stat.isFile())
+                continue;
+            mode = opts.platform === "win32" ? undefined : stat.mode & 0o777;
+            text = readFileSync(c.path, "utf8");
+        }
+        catch {
+            continue;
+        }
+        let data;
+        try {
+            data = parseConfig(c.path, text);
+        }
+        catch (error) {
+            result.unreadable.push({ client: c.client, path: c.path, error: error.message });
+            continue;
+        }
+        const exposure = mode === undefined ? undefined : exposureOf(mode, ancestorModes(c.path));
+        const file = { client: c.client, path: c.path, data, mode, exposure };
+        result.files.push(file);
+        if (!isObject(data))
+            continue;
+        switch (c.kind) {
+            case "mcp":
+                result.servers.push(...serversAt(c.client, c.path, "mcpServers", data.mcpServers));
+                break;
+            case "claude-json":
+                result.servers.push(...serversAt(c.client, c.path, "mcpServers", data.mcpServers));
+                if (isObject(data.projects)) {
+                    for (const [project, conf] of Object.entries(data.projects)) {
+                        if (!isObject(conf))
+                            continue;
+                        const base = pointerJoin(pointerJoin("projects", project), "mcpServers");
+                        result.servers.push(...serversAt(c.client, c.path, base, conf.mcpServers));
+                    }
+                }
+                break;
+            case "claude-settings":
+                result.approvals.push(...claudeApprovals(file));
+                break;
+            case "codex":
+                result.servers.push(...serversAt(c.client, c.path, "mcp_servers", data.mcp_servers));
+                break;
+            case "vscode-settings":
+                if (isObject(data.mcp))
+                    result.servers.push(...serversAt(c.client, c.path, "mcp.servers", data.mcp.servers));
+                break;
+            case "vscode-mcp":
+                result.servers.push(...serversAt(c.client, c.path, "servers", data.servers));
+                break;
+        }
+    }
+    return result;
+}

package/dist/types.d.ts

@@ -0,0 +1,69 @@
+/** `info` findings are context only and do not affect the score. */
+export type Severity = "high" | "medium" | "low" | "info";
+export type ClientId = "claude-code" | "claude-desktop" | "cursor" | "codex" | "vscode" | "windsurf" | "gemini" | "cline";
+export interface Location {
+    /** Absolute path of the config file. */
+    file: string;
+    /** Dotted path to the value inside the file, for example `mcpServers.github.env.TOKEN`. */
+    pointer: string;
+}
+export interface ConfigFile {
+    client: ClientId;
+    path: string;
+    /** Parsed file contents. */
+    data: unknown;
+    /** Unix permission bits, when available. */
+    mode?: number;
+    /** Who besides the owner can read the file, counting the folders above it. */
+    exposure?: "group" | "others" | null;
+}
+export interface ServerEntry {
+    client: ClientId;
+    file: string;
+    /** Pointer to the server object, for example `mcpServers.github`. */
+    pointer: string;
+    name: string;
+    command?: string;
+    args: string[];
+    env: Record<string, string>;
+    url?: string;
+    headers: Record<string, string>;
+    /** Other string fields that may carry credentials, such as Codex `bearer_token`. */
+    extraSecrets: Record<string, string>;
+    /** Tools listed under client auto-approval keys (`alwaysAllow`, `autoApprove`). */
+    autoApproved: string[];
+}
+/** Client settings that approve MCP tools without asking. */
+export interface ApprovalSetting {
+    client: ClientId;
+    location: Location;
+    /** What is approved, for example `mcp__github` or `all project servers`. */
+    subject: string;
+}
+export interface Finding {
+    rule: string;
+    severity: Severity;
+    title: string;
+    detail: string;
+    fix: string;
+    locations: Location[];
+    /** Points this finding takes off the score; repeats of one root cause count once. */
+    weight: number;
+}
+export interface AuditResult {
+    files: {
+        client: ClientId;
+        path: string;
+    }[];
+    /** Files that exist but could not be parsed. */
+    unreadable: {
+        client: ClientId;
+        path: string;
+        error: string;
+    }[];
+    servers: number;
+    clients: ClientId[];
+    findings: Finding[];
+    score: number | null;
+    grade: string | null;
+}

package/dist/types.js

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

package/package.json

@@ -1,6 +1,55 @@
 {
   "name": "toolstile",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "description": "Audit the MCP server configs your AI agents use for plaintext secrets, unpinned packages, auto-approved tools and duplicated setups. Local and read-only.",
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "security",
+    "audit",
+    "claude",
+    "cursor",
+    "codex",
+    "secrets"
+  ],
+  "homepage": "https://github.com/toolstile/cli#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/toolstile/cli.git"
+  },
+  "bugs": {
+    "email": "support@toolstile.com"
+  },
+  "author": "Akshit Kr Nagpal <hello@akshit.io> (https://akshit.io)",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "toolstile": "dist/cli.js"
+  },
+  "exports": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.build.json && chmod +x dist/cli.js",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "prepublishOnly": "pnpm typecheck && pnpm build && pnpm test"
+  },
+  "dependencies": {
+    "smol-toml": "^1.9.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.19.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.0"
+  },
+  "packageManager": "pnpm@11.20.0",
+  "optionalDependencies": {
+    "@resvg/resvg-js": "^2.6.2"
+  }
+}