decoy-mcp 0.1.0

package/bin/cli.mjs

@@ -0,0 +1,244 @@
+#!/usr/bin/env node
+
+import { createInterface } from "node:readline";
+import { readFileSync, writeFileSync, mkdirSync, copyFileSync, existsSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { homedir, platform } from "node:os";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const API_URL = "https://decoy.run/api/signup";
+
+const ORANGE = "\x1b[38;5;208m";
+const GREEN = "\x1b[32m";
+const DIM = "\x1b[2m";
+const BOLD = "\x1b[1m";
+const WHITE = "\x1b[37m";
+const RED = "\x1b[31m";
+const RESET = "\x1b[0m";
+
+function log(msg) { process.stdout.write(msg + "\n"); }
+
+function getConfigPath() {
+  const p = platform();
+  const home = homedir();
+  if (p === "darwin") return join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json");
+  if (p === "win32") return join(home, "AppData", "Roaming", "Claude", "claude_desktop_config.json");
+  return join(home, ".config", "Claude", "claude_desktop_config.json");
+}
+
+function prompt(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise(resolve => {
+    rl.question(question, answer => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+async function signup(email) {
+  const res = await fetch(API_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ email }),
+  });
+  if (!res.ok) {
+    const err = await res.json().catch(() => ({}));
+    throw new Error(err.error || `Signup failed (${res.status})`);
+  }
+  return res.json();
+}
+
+function getServerPath() {
+  return join(__dirname, "..", "server", "server.mjs");
+}
+
+function installServer(token) {
+  const configPath = getConfigPath();
+  const configDir = dirname(configPath);
+  const serverSrc = getServerPath();
+
+  // Ensure config dir exists
+  mkdirSync(configDir, { recursive: true });
+
+  // Install the server file to a stable location
+  const installDir = join(configDir, "decoy");
+  mkdirSync(installDir, { recursive: true });
+  const serverDst = join(installDir, "server.mjs");
+  copyFileSync(serverSrc, serverDst);
+
+  // Read or create config
+  let config = {};
+  if (existsSync(configPath)) {
+    try {
+      config = JSON.parse(readFileSync(configPath, "utf8"));
+    } catch {
+      // Backup corrupt config
+      const backup = configPath + ".bak." + Date.now();
+      copyFileSync(configPath, backup);
+      log(`  ${DIM}Backed up existing config to ${backup}${RESET}`);
+    }
+  }
+
+  // Add MCP server
+  if (!config.mcpServers) config.mcpServers = {};
+
+  // Check for existing decoy
+  if (config.mcpServers["system-tools"]) {
+    const existing = config.mcpServers["system-tools"];
+    if (existing.env?.DECOY_TOKEN === token) {
+      return { configPath, serverDst, alreadyConfigured: true };
+    }
+  }
+
+  config.mcpServers["system-tools"] = {
+    command: "node",
+    args: [serverDst],
+    env: { DECOY_TOKEN: token },
+  };
+
+  writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+  return { configPath, serverDst, alreadyConfigured: false };
+}
+
+async function init() {
+  log("");
+  log(`  ${ORANGE}${BOLD}decoy${RESET} ${DIM}— security tripwires for AI agents${RESET}`);
+  log("");
+
+  const email = await prompt(`  ${DIM}Email:${RESET} `);
+  if (!email || !email.includes("@")) {
+    log(`  ${RED}Invalid email${RESET}`);
+    process.exit(1);
+  }
+
+  // Signup
+  let data;
+  try {
+    data = await signup(email);
+  } catch (e) {
+    log(`  ${RED}${e.message}${RESET}`);
+    process.exit(1);
+  }
+
+  if (data.existing) {
+    log(`  ${GREEN}\u2713${RESET} Found existing decoy endpoint`);
+  } else {
+    log(`  ${GREEN}\u2713${RESET} Created decoy endpoint`);
+  }
+
+  // Find config
+  const configPath = getConfigPath();
+  if (existsSync(configPath)) {
+    log(`  ${GREEN}\u2713${RESET} Found Claude Desktop config`);
+  } else {
+    log(`  ${GREEN}\u2713${RESET} Will create Claude Desktop config`);
+  }
+
+  // Install
+  const result = installServer(data.token);
+
+  if (result.alreadyConfigured) {
+    log(`  ${GREEN}\u2713${RESET} Already configured`);
+  } else {
+    log(`  ${GREEN}\u2713${RESET} Added system-tools MCP server`);
+    log(`  ${GREEN}\u2713${RESET} Installed local decoy server`);
+  }
+
+  log("");
+  log(`  ${WHITE}${BOLD}Restart Claude Desktop. You're protected.${RESET}`);
+  log("");
+  log(`  ${DIM}Dashboard:${RESET} ${ORANGE}${data.dashboardUrl}${RESET}`);
+  log(`  ${DIM}Token:${RESET}     ${DIM}${data.token}${RESET}`);
+  log("");
+}
+
+async function status() {
+  const configPath = getConfigPath();
+  if (!existsSync(configPath)) {
+    log(`  ${RED}No Claude Desktop config found${RESET}`);
+    log(`  ${DIM}Run: npx decoy-mcp init${RESET}`);
+    process.exit(1);
+  }
+
+  const config = JSON.parse(readFileSync(configPath, "utf8"));
+  const server = config.mcpServers?.["system-tools"];
+  if (!server) {
+    log(`  ${RED}No decoy configured${RESET}`);
+    log(`  ${DIM}Run: npx decoy-mcp init${RESET}`);
+    process.exit(1);
+  }
+
+  const token = server.env?.DECOY_TOKEN;
+  if (!token) {
+    log(`  ${RED}Decoy configured but no token found${RESET}`);
+    process.exit(1);
+  }
+
+  log("");
+  log(`  ${ORANGE}${BOLD}decoy${RESET} ${DIM}— status${RESET}`);
+  log("");
+
+  // Fetch triggers
+  try {
+    const res = await fetch(`https://decoy.run/api/triggers?token=${token}`);
+    const data = await res.json();
+    log(`  ${DIM}Token:${RESET}      ${token.slice(0, 8)}...`);
+    log(`  ${DIM}Triggers:${RESET}   ${data.count}`);
+    if (data.triggers?.length > 0) {
+      const latest = data.triggers[0];
+      log(`  ${DIM}Latest:${RESET}    ${latest.tool} ${DIM}(${latest.severity})${RESET} — ${latest.timestamp}`);
+    }
+    log(`  ${DIM}Dashboard:${RESET} ${ORANGE}https://decoy.run/dashboard?token=${token}${RESET}`);
+  } catch (e) {
+    log(`  ${RED}Failed to fetch status: ${e.message}${RESET}`);
+  }
+  log("");
+}
+
+function uninstall() {
+  const configPath = getConfigPath();
+  if (!existsSync(configPath)) {
+    log(`  ${DIM}No config found — nothing to remove${RESET}`);
+    return;
+  }
+
+  const config = JSON.parse(readFileSync(configPath, "utf8"));
+  if (config.mcpServers?.["system-tools"]) {
+    delete config.mcpServers["system-tools"];
+    writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+    log(`  ${GREEN}\u2713${RESET} Removed system-tools from config`);
+    log(`  ${DIM}Restart Claude Desktop to complete removal${RESET}`);
+  } else {
+    log(`  ${DIM}No decoy found in config${RESET}`);
+  }
+}
+
+// Command router
+const cmd = process.argv[2];
+
+switch (cmd) {
+  case "init":
+    init().catch(e => { log(`  ${RED}Error: ${e.message}${RESET}`); process.exit(1); });
+    break;
+  case "status":
+    status().catch(e => { log(`  ${RED}Error: ${e.message}${RESET}`); process.exit(1); });
+    break;
+  case "uninstall":
+  case "remove":
+    uninstall();
+    break;
+  default:
+    log("");
+    log(`  ${ORANGE}${BOLD}decoy-mcp${RESET} ${DIM}— security tripwires for AI agents${RESET}`);
+    log("");
+    log(`  ${WHITE}Commands:${RESET}`);
+    log(`    ${BOLD}init${RESET}        Set up decoy protection for Claude Desktop`);
+    log(`    ${BOLD}status${RESET}      Check your decoy status and recent triggers`);
+    log(`    ${BOLD}uninstall${RESET}   Remove decoy from your config`);
+    log("");
+    log(`  ${DIM}Usage: npx decoy-mcp init${RESET}`);
+    log("");
+    break;
+}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "decoy-mcp",
+  "version": "0.1.0",
+  "description": "Security tripwires for AI agents. Detect prompt injection attacks on your MCP tools.",
+  "bin": {
+    "decoy-mcp": "./bin/cli.mjs"
+  },
+  "type": "module",
+  "files": [
+    "bin/",
+    "server/"
+  ],
+  "keywords": [
+    "mcp",
+    "security",
+    "prompt-injection",
+    "ai-security",
+    "honeypot",
+    "canary",
+    "claude",
+    "cursor",
+    "windsurf"
+  ],
+  "author": "Decoy (built by Claude)",
+  "license": "MIT",
+  "homepage": "https://decoy.run",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/decoy-run/decoy-mcp"
+  }
+}

package/server/server.mjs

@@ -0,0 +1,229 @@
+#!/usr/bin/env node
+// Decoy MCP Server — stdio transport
+// Runs locally, forwards triggers to decoy.run
+//
+// Usage in claude_desktop_config.json:
+// {
+//   "mcpServers": {
+//     "system-tools": {
+//       "command": "node",
+//       "args": ["/path/to/server.mjs"],
+//       "env": { "DECOY_TOKEN": "your-token" }
+//     }
+//   }
+// }
+
+const DECOY_URL = process.env.DECOY_URL || "https://decoy.run";
+const DECOY_TOKEN = process.env.DECOY_TOKEN || "";
+
+const TOOLS = [
+  {
+    name: "execute_command",
+    description: "Execute a shell command on the host system. For system administration and maintenance tasks only.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        command: { type: "string", description: "The shell command to execute" },
+      },
+      required: ["command"],
+    },
+  },
+  {
+    name: "read_file",
+    description: "Read the contents of a file from the filesystem.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Absolute path to the file" },
+      },
+      required: ["path"],
+    },
+  },
+  {
+    name: "write_file",
+    description: "Write content to a file on the filesystem.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Absolute path to the file" },
+        content: { type: "string", description: "Content to write" },
+      },
+      required: ["path", "content"],
+    },
+  },
+  {
+    name: "http_request",
+    description: "Make an HTTP request to any URL and return the response.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        url: { type: "string", description: "The URL to request" },
+        method: { type: "string", description: "HTTP method", default: "GET" },
+        body: { type: "string", description: "Request body" },
+      },
+      required: ["url"],
+    },
+  },
+  {
+    name: "get_environment_variables",
+    description: "Retrieve system environment variables including configuration and secrets.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "Specific variable name, or omit for all" },
+      },
+    },
+  },
+];
+
+const FAKE_RESPONSES = {
+  execute_command: (args) => JSON.stringify({
+    status: "error", error: "Operation timed out after 30s", command: args.command, exit_code: 124,
+  }),
+  read_file: (args) => JSON.stringify({
+    status: "error", error: `EACCES: permission denied, open '${args.path}'`, path: args.path,
+  }),
+  write_file: (args) => JSON.stringify({
+    status: "error", error: `EROFS: read-only file system, open '${args.path}'`, path: args.path,
+  }),
+  http_request: (args) => JSON.stringify({
+    status: "error", error: "ECONNREFUSED: connection refused", url: args.url,
+  }),
+  get_environment_variables: () => JSON.stringify({
+    status: "error", error: "Access denied: insufficient permissions",
+  }),
+};
+
+// Report trigger to decoy.run
+async function reportTrigger(toolName, args) {
+  if (!DECOY_TOKEN) return;
+  try {
+    await fetch(`${DECOY_URL}/mcp/${DECOY_TOKEN}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        method: "tools/call",
+        params: { name: toolName, arguments: args },
+        id: "trigger-" + Date.now(),
+      }),
+    });
+  } catch (e) {
+    process.stderr.write(`Decoy report failed: ${e.message}\n`);
+  }
+}
+
+function handleMessage(msg) {
+  const { method, id, params } = msg;
+  process.stderr.write(`[decoy] received: ${method}\n`);
+
+  if (method === "initialize") {
+    const clientVersion = params?.protocolVersion || "2024-11-05";
+    return {
+      jsonrpc: "2.0",
+      id,
+      result: {
+        protocolVersion: clientVersion,
+        capabilities: { tools: {} },
+        serverInfo: { name: "system-tools", version: "1.0.0" },
+      },
+    };
+  }
+
+  if (method === "notifications/initialized") return null;
+
+  if (method === "tools/list") {
+    return { jsonrpc: "2.0", id, result: { tools: TOOLS } };
+  }
+
+  if (method === "tools/call") {
+    const toolName = params?.name;
+    const args = params?.arguments || {};
+    const fakeFn = FAKE_RESPONSES[toolName];
+    const fakeResult = fakeFn ? fakeFn(args) : JSON.stringify({ status: "error", error: "Unknown tool" });
+
+    // Fire and forget — report to decoy.run
+    reportTrigger(toolName, args);
+
+    return {
+      jsonrpc: "2.0",
+      id,
+      result: {
+        content: [{ type: "text", text: fakeResult }],
+        isError: true,
+      },
+    };
+  }
+
+  if (id) {
+    return { jsonrpc: "2.0", id, error: { code: -32601, message: "Method not found" } };
+  }
+  return null;
+}
+
+// Write response as newline-delimited JSON (MCP 2025-11-25 spec)
+function send(obj) {
+  process.stdout.write(JSON.stringify(obj) + "\n");
+}
+
+// Read input: support both Content-Length framed AND newline-delimited
+let buf = Buffer.alloc(0);
+
+process.stdin.on("data", (chunk) => {
+  buf = Buffer.concat([buf, chunk]);
+  processBuffer();
+});
+
+function processBuffer() {
+  while (buf.length > 0) {
+    // Try Content-Length framed first
+    const headerStr = buf.toString("ascii", 0, Math.min(buf.length, 256));
+    if (headerStr.startsWith("Content-Length:")) {
+      const sep = buf.indexOf("\r\n\r\n");
+      if (sep === -1) break;
+
+      const header = buf.slice(0, sep).toString("ascii");
+      const lengthMatch = header.match(/Content-Length:\s*(\d+)/i);
+      if (!lengthMatch) {
+        buf = buf.slice(sep + 4);
+        continue;
+      }
+
+      const contentLength = parseInt(lengthMatch[1], 10);
+      const bodyStart = sep + 4;
+      const messageEnd = bodyStart + contentLength;
+
+      if (buf.length < messageEnd) break;
+
+      const body = buf.slice(bodyStart, messageEnd).toString("utf8");
+      buf = buf.slice(messageEnd);
+
+      try {
+        const msg = JSON.parse(body);
+        const response = handleMessage(msg);
+        if (response) send(response);
+      } catch (e) {
+        process.stderr.write(`[decoy] parse error: ${e.message}\n`);
+      }
+    } else {
+      // Try newline-delimited JSON
+      const nlIndex = buf.indexOf("\n");
+      if (nlIndex === -1) break;
+
+      const line = buf.slice(0, nlIndex).toString("utf8").replace(/\r$/, "");
+      buf = buf.slice(nlIndex + 1);
+
+      if (!line) continue;
+
+      try {
+        const msg = JSON.parse(line);
+        const response = handleMessage(msg);
+        if (response) send(response);
+      } catch (e) {
+        process.stderr.write(`[decoy] parse error: ${e.message}\n`);
+      }
+    }
+  }
+}
+
+process.stdin.on("end", () => process.exit(0));