@nodatachat/mcp 0.7.0 → 0.9.0

package/dist/index.js

@@ -31,12 +31,16 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
+// Our deepest content scanner, shipped as its own zero-dep, Node-native npm
+// package. nodata_scan_folder wires to it directly (not a reimplementation) so
+// the "SEE what's sensitive" step runs INSIDE this one command, entirely local.
+import { runFolderScan, silentLogger, formatFolderScan } from "@nodatachat/folder-scan";
 import { homedir, hostname } from "node:os";
-import { join } from "node:path";
+import { join, resolve, basename } from "node:path";
 import { existsSync, readFileSync, writeFileSync, mkdirSync, chmodSync } from "node:fs";
 import { spawn } from "node:child_process";
 import { generateKeyPairSync, createPrivateKey, sign, randomBytes } from "node:crypto";
-const VERSION = "0.7.0";
+const VERSION = "0.9.0";
 // ---------------------------------------------------------------------------
 // Local credential store — "register once, autoload forever"
 // ---------------------------------------------------------------------------
@@ -595,58 +599,59 @@ function registerAgentTool(server, baseUrl, grantToken) {
         return formatResult(resp);
     });
 }
-const START_ACHIEVEMENT = "WHAT YOU GET WITH NODATA — in one line:\n" +
-    "  Give any agent real power over your data, without ever giving it the power to leak it.\n" +
-    "  (Possession is not permission: an agent can hold the key and still not read what you didn't allow.)\n";
-// Setup / admin readers are the developer wiring governance up — outcomes point
-// at the admin verbs (register / grant / encrypt / deliver) and the no-setup web door.
-const START_OUTCOMES_ADMIN = "PICK AN OUTCOME — the win first, the step under it:\n\n" +
-    "[1] An agent that cannot leak\n" +
-    "    It sees only the classifications you allow; the rest never decrypts for it, and every\n" +
-    "    disclosure returns a signed receipt.\n" +
-    "    Start: tell me \"give <agent> public + internal, hide the rest\" — I register the data\n" +
-    "    (nodata_register_table) and issue the grant (nodata_grant); nodata_revoke cuts it off anytime.\n\n" +
-    "[2] See what is already exposed — no setup\n" +
-    "    Know exactly which sensitive fields your agent already received, before you change anything.\n" +
-    "    Start: https://www.nodatacapsule.com/trace-inspector  (runs in your browser, nothing uploaded).\n\n" +
-    "[3] A secret you hold that NoData cannot read\n" +
-    "    Encrypt a value even NoData's server cannot open, then hand it over as a one-time link.\n" +
-    "    Start: nodata_encrypt, then nodata_deliver.\n";
+const START_ACHIEVEMENT = "WHAT NODATA DOES — in one line:\n" +
+    "  Give any agent real power over your data, without the power to leak it.\n" +
+    "  (Possession is not permission: it can hold the key and still not read what you didn't allow.)\n";
+// Setup mode: NOT connected yet. The one job here is to switch the tools on, so
+// this is a numbered do-this-exactly list — three steps, not a catalogue. The
+// last line answers the two questions everyone asks: "how do I activate?" (/mcp)
+// and "what about next time?" (nothing).
+const SETUP_STEPS = "TURN THE DATA TOOLS ON — 3 steps, about a minute, once:\n\n" +
+    "  1. GET A KEY   call  nodata_connect  (no arguments)\n" +
+    "                 -> opens the signup in your browser: email + company (~30s), a 12-word\n" +
+    "                    recovery phrase to keep, and an ORG KEY shown ONCE. Copy that key.\n\n" +
+    "  2. SAVE IT     call  nodata_connect  again, this time with\n" +
+    "                    api_key: \"<the key you copied>\"\n" +
+    "                 -> saved on this machine; you never paste it again.\n\n" +
+    "  3. ACTIVATE    type  /mcp  (or restart Claude Code) so the tools load.\n\n" +
+    "COMING BACK LATER? Nothing to redo — it starts ready. If the tools look missing, just /mcp.\n";
+// Admin mode: connected. Frame the whole product as the developer's real journey
+// — SEE -> CHOOSE -> PROVE — each step a plain-language ask mapped to a tool.
+const START_OUTCOMES_ADMIN = "NOW — TURN YOUR DATA INTO AN AGENT THAT CAN'T LEAK, in 3 asks (just say them in plain words):\n\n" +
+    "  1. SEE what's sensitive    run  nodata_scan_folder  — scans a local folder right here, nothing\n" +
+    "                             uploads (or open https://www.nodatacapsule.com/ai-folder in a browser).\n\n" +
+    "  2. CHOOSE what to release  say  \"let <agent> read name + plan on <table>, hide the rest\"\n" +
+    "                             -> I run nodata_register_table + nodata_grant; the agent gets a token.\n\n" +
+    "  3. PROVE & control         the agent now reads ONLY those columns — the rest never decrypt.\n" +
+    "                             \"what did it see?\" -> nodata_evidence   ·   \"cut it off\" -> nodata_revoke\n\n" +
+    "Also: a secret even NoData can't read -> nodata_encrypt, then hand it over once -> nodata_deliver.\n";
 // The agent-scoped reader IS the governed agent: it holds only decide/retrieve/read/use,
-// so its outcomes name those verbs (pointing it at admin tools it lacks would dead-end it).
-const START_OUTCOMES_AGENT = "WHAT YOU CAN DO — scoped to your grant, the win first, the step under it:\n\n" +
-    "[1] Know before you read\n" +
-    "    Check whether you MAY reach something without pulling any data — allow / degrade to the\n" +
-    "    reachable subset / deny, with an access-distance cost and a signed proof.\n" +
-    "    Start: nodata_decide.\n\n" +
-    "[2] Pull only what you're allowed\n" +
-    "    Prompt-ready context filtered to exactly your permitted fields; denied fields never decrypt,\n" +
-    "    and you get an accounting of what was withheld plus a receipt.\n" +
-    "    Start: nodata_retrieve (or nodata_read for governed rows).\n\n" +
-    "[3] Use a secret you never see\n" +
-    "    Invoke a pre-registered capability; the Capsule injects the sealed credential server-side and\n" +
-    "    returns only the result. The secret never reaches you.\n" +
-    "    Start: nodata_use.\n";
-const START_UNSTUCK = "IF IT SEEMS STUCK — there is always a next step:\n" +
-    "  - Don't see the nodata_* tools yet? They load when the MCP client starts. Restart Claude Code\n" +
-    "    (or run /mcp). This is expected, not an error.\n" +
-    "  - No MCP at all, or it won't connect? The same governance runs without it — one curl, or the\n" +
-    "    guided page at https://www.nodatacapsule.com/developers/get-started\n";
+// so its steps name those verbs (pointing it at admin tools it lacks would dead-end it).
+const START_OUTCOMES_AGENT = "WHAT YOU CAN DO — scoped to your grant; you reach only what it allows, the rest never decrypts:\n\n" +
+    "  1. PLAN   nodata_decide     \"may I reach X?\" -> allow / partial / deny + a signed proof. No data moves.\n" +
+    "  2. PULL   nodata_retrieve   prompt-ready context, allowed fields only, with a receipt.\n" +
+    "            (nodata_read for raw governed rows.)\n" +
+    "  3. ACT    nodata_use        run a capability with a secret injected server-side — you never see it.\n";
+const START_UNSTUCK = "STUCK? There's always a next step:\n" +
+    "  - Don't see the nodata_* tools? They load when the client starts — type  /mcp  or restart.\n" +
+    "    (Expected, not an error.)\n" +
+    "  - No MCP at all? The same governance runs from one curl, or the guided page:\n" +
+    "    https://www.nodatacapsule.com/developers/get-started\n";
 function startHeader(mode) {
     if (mode === "setup") {
-        return ("You're connected to NoData, but WITHOUT a credential yet, so the data tools are still off.\n" +
-            "Fastest unlock — nothing to retype: call nodata_connect. It opens the free signup in your\n" +
-            "browser (email + company, ~30s, with your recovery phrase + email verify), then you call it\n" +
-            "once more with the key it shows and it's SAVED — every later start comes up ready, and the\n" +
-            "only step left is one /mcp so the client reloads the tools.\n\n");
+        return "You're connected to NoData — but there's NO key yet, so the data tools are still off.\n\n";
     }
     if (mode === "agent") {
-        return ("You're connected to NoData, scoped to one grant token: you can reach only what that grant\n" +
-            "allows, and denied fields never decrypt for you. Plan with nodata_decide, then nodata_retrieve.\n\n");
+        return "You're connected to NoData, scoped to one grant token.\n\n";
     }
-    return "You're connected to NoData (admin). Everything below is one plain-language ask away.\n\n";
+    return "You're connected to NoData (admin mode). You don't memorize commands — just ask in plain words.\n\n";
 }
 function getStartedText(mode) {
+    // Setup leads with the 3 connect steps (the only thing that matters when off);
+    // admin/agent lead with the journey they can act on right now.
+    if (mode === "setup") {
+        return startHeader(mode) + START_ACHIEVEMENT + "\n" + SETUP_STEPS + "\n" + START_UNSTUCK;
+    }
     const outcomes = mode === "agent" ? START_OUTCOMES_AGENT : START_OUTCOMES_ADMIN;
     return startHeader(mode) + START_ACHIEVEMENT + "\n" + outcomes + "\n" + START_UNSTUCK;
 }
@@ -687,11 +692,11 @@ function openInBrowser(url) {
 }
 function registerConnectTool(server, baseUrl) {
     server.registerTool("nodata_connect", {
-        description: "Switch NoData's data tools on. Call with NO arguments to open the free signup in a " +
-            "browser (email + company, ~30s — also where your recovery phrase + email verification " +
-            "happen). It shows an org key ONCE; call this tool again with that key as `api_key` and it " +
-            "is saved locally, so every later start comes up ready with nothing to retype. After saving, " +
-            "reconnect (/mcp) or restart so the client loads the tools.",
+        description: "Switch NoData's data tools on. Step 1: call with NO arguments to open the free signup in a " +
+            "browser (email + company, ~30s — also where your 12-word recovery phrase + email verification " +
+            "happen); it shows an ORG KEY once. Step 2: call this tool again with that key as `api_key` and " +
+            "it is saved on this machine, so every later start comes up ready with nothing to retype. " +
+            "Step 3: type /mcp (or restart) so the client loads the tools.",
         inputSchema: {
             api_key: z
                 .string()
@@ -708,15 +713,16 @@ function registerConnectTool(server, baseUrl) {
                 content: [
                     {
                         type: "text",
-                        text: (opened ? "Opened the NoData signup in your browser:\n  " : "Open the NoData signup in your browser:\n  ") +
+                        text: (opened ? "STEP 1 of 3 — opened the NoData signup in your browser:\n  " : "STEP 1 of 3 — open the NoData signup in your browser:\n  ") +
                             url +
                             "\n\n" +
-                            "It takes ~30s (email + company; a personal email is fine for the sandbox). You'll also\n" +
-                            "set a 12-word recovery phrase and verify your email there — keep the recovery phrase, it\n" +
-                            "is the only way back into the org.\n\n" +
-                            "The page shows an ORG KEY exactly once. Copy it, then call nodata_connect again with\n" +
-                            '  api_key: "<that key>"\n' +
-                            "and I'll save it so you never paste it again.",
+                            "There, about a minute:\n" +
+                            "  - email + company (a personal email is fine for the sandbox)\n" +
+                            "  - a 12-WORD RECOVERY PHRASE — save it; it is the only way back into your org\n" +
+                            "  - your ORG KEY, shown ONCE — copy it\n\n" +
+                            "STEP 2 — come back and call this tool again with the key:\n" +
+                            '  nodata_connect  api_key: "<the key you copied>"\n' +
+                            "and I'll save it so you never paste it again. (Then STEP 3: type /mcp to activate.)",
                     },
                 ],
             };
@@ -762,10 +768,10 @@ function registerConnectTool(server, baseUrl) {
                 content: [
                     {
                         type: "text",
-                        text: `Done — this device is enrolled as "${label}" (${handle}), and only its PRIVATE key is saved\n` +
-                            "at ~/.nodata/credentials.json (readable only by you). The org key you pasted was NOT stored:\n" +
-                            "every start now proves possession by signing a fresh challenge and gets a 15-minute token.\n\n" +
-                            "Reconnect (run /mcp, or restart Claude Code) and the admin tools will be there.",
+                        text: `STEP 2 done — this device is enrolled as "${label}" (${handle}), and only its PRIVATE key is\n` +
+                            "saved at ~/.nodata/credentials.json (readable only by you). The org key you pasted was NOT\n" +
+                            "stored: every start now proves possession by signing a fresh challenge and gets a 15-minute token.\n\n" +
+                            "STEP 3 — type /mcp (or restart Claude Code) and the admin tools appear. Next time: nothing to do.",
                     },
                 ],
             };
@@ -793,16 +799,75 @@ function registerConnectTool(server, baseUrl) {
                 {
                     type: "text",
                     text: (attestUnavailable
-                        ? "Saved your key locally (device attestation isn't available on this server yet, so this is the\nkey-at-rest path). "
-                        : `Saved your key locally (device enrollment didn't succeed: ${enrolled.error}). `) +
+                        ? "STEP 2 done — saved your key on this machine (device attestation isn't available on this\nserver yet, so this is the key-at-rest path). "
+                        : `STEP 2 done — saved your key on this machine (device enrollment didn't succeed: ${enrolled.error}). `) +
                         "Every future start loads it automatically — no re-register, no re-paste.\n\n" +
-                        "Reconnect (run /mcp, or restart Claude Code) and the admin tools will be there.",
+                        "STEP 3 — type /mcp (or restart Claude Code) and the admin tools appear. Next time: nothing to do.",
                 },
             ],
         };
     });
 }
 // ---------------------------------------------------------------------------
+// nodata_scan_folder — SEE what's sensitive, locally, before you govern it
+// ---------------------------------------------------------------------------
+// The journey's first step ("SEE") brought inside the one command. It runs our
+// deep content scanner (the published @nodatachat/folder-scan — the same detection
+// engine the NoData agent uses: 24 secret patterns + checksum-validated PII, and
+// PDF/Office text extraction) ENTIRELY on this machine — nothing uploads — over a
+// folder the developer names, then points at register_table + grant for what it
+// surfaces. Local compute needs no credential, so this is offered even in setup
+// mode: scan before you even sign up.
+function formatScanReport(r) {
+    // The neutral report comes from the scanner package (shared with its CLI);
+    // the MCP only adds the governance bridge — turn what the scan surfaced into
+    // the next step of the same journey.
+    const base = formatFolderScan(r);
+    if (r.error)
+        return base;
+    return (base +
+        "\n\nGOVERN what it surfaced — same journey, inside this command:\n" +
+        "  · CHOOSE what an agent may read:  nodata_register_table  then  nodata_grant   (denied columns never decrypt)\n" +
+        "  · PROVE every access afterwards:  nodata_evidence\n" +
+        "\nWant a standalone deep scan any time? npx @nodatachat/folder-scan  (this same engine).");
+}
+function registerScanFolderTool(server) {
+    server.registerTool("nodata_scan_folder", {
+        description: "SEE what's sensitive before you govern it. Scans a LOCAL folder for hardcoded secrets and unencrypted PII (checksum-validated — Israeli ID / Luhn credit-card / IBAN) with NoData's deep content scanner, reading PDFs and Office files too, ENTIRELY on this machine — nothing uploads, no credential needed. Returns the findings by file and severity plus the first fix, then points at nodata_register_table + nodata_grant to govern what it found. If the user asks to scan / audit / check a folder or repo for sensitive data, secrets, or exposure, call this.",
+        inputSchema: {
+            path: z
+                .string()
+                .optional()
+                .describe("Folder to scan (absolute or relative). Default: the directory the server runs in."),
+        },
+    }, async ({ path: scanPath }) => {
+        const dir = (scanPath ?? ".").trim() || ".";
+        const absDir = resolve(dir);
+        if (!existsSync(absDir)) {
+            return {
+                content: [{ type: "text", text: `No folder found at: ${absDir}\nPass an existing path, e.g. nodata_scan_folder path: "."` }],
+            };
+        }
+        try {
+            // Deep scanner: async, takes an injected logger. silentLogger keeps the
+            // MCP's stdout (JSON-RPC) clean; the scan never writes to stdout itself.
+            const report = await runFolderScan({
+                target_id: "mcp",
+                target_label: basename(absDir),
+                target_path: absDir,
+                log: silentLogger,
+            });
+            return { content: [{ type: "text", text: formatScanReport(report) }] };
+        }
+        catch (e) {
+            return {
+                content: [{ type: "text", text: `Scan failed: ${e instanceof Error ? e.message : String(e)}` }],
+                isError: true,
+            };
+        }
+    });
+}
+// ---------------------------------------------------------------------------
 // Server setup
 // ---------------------------------------------------------------------------
 async function main() {
@@ -821,6 +886,10 @@ async function main() {
     if (grantToken)
         registerAgentTool(server, baseUrl, grantToken);
     registerGetStarted(server, mode);
+    // The local exposure scan needs no credential — offer it wherever the owner is
+    // driving (setup, before signup, or admin), just not to a scoped agent.
+    if (mode !== "agent")
+        registerScanFolderTool(server);
     if (mode === "setup") {
         registerConnectTool(server, baseUrl);
         console.error("nodata-mcp: no credential given — running in setup mode (data tools disabled).\n" +

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nodatachat/mcp",
-  "version": "0.7.0",
-  "description": "NoData MCP Server — govern data AND code for AI agents: decide (may I?) + retrieve (authorized context) + read + secret-blind invoke + blind code advise/patch (fix code without exposure), plus admin governance/encrypt/decrypt/deliver",
+  "version": "0.9.0",
+  "description": "NoData MCP Server — scan a folder for exposure (locally, nothing uploads) + govern data AND code for AI agents: decide (may I?) + retrieve (authorized context) + read + secret-blind invoke + blind code advise/patch (fix code without exposure), plus admin governance/encrypt/decrypt/deliver",
   "bin": {
     "nodata-mcp": "dist/index.js"
   },
@@ -13,6 +13,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
+    "@nodatachat/folder-scan": "^1.0.0",
     "zod": "^4.0.0"
   },
   "devDependencies": {